Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph...
[~shefty/rdma-dev.git] / fs / ceph / xattr.c
1 #include <linux/ceph/ceph_debug.h>
2
3 #include "super.h"
4 #include "mds_client.h"
5
6 #include <linux/ceph/decode.h>
7
8 #include <linux/xattr.h>
9 #include <linux/slab.h>
10
11 #define XATTR_CEPH_PREFIX "ceph."
12 #define XATTR_CEPH_PREFIX_LEN (sizeof (XATTR_CEPH_PREFIX) - 1)
13
14 static bool ceph_is_valid_xattr(const char *name)
15 {
16         return !strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN) ||
17                !strncmp(name, XATTR_SECURITY_PREFIX,
18                         XATTR_SECURITY_PREFIX_LEN) ||
19                !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) ||
20                !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
21 }
22
23 /*
24  * These define virtual xattrs exposing the recursive directory
25  * statistics and layout metadata.
26  */
27 struct ceph_vxattr {
28         char *name;
29         size_t name_size;       /* strlen(name) + 1 (for '\0') */
30         size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val,
31                               size_t size);
32         bool readonly;
33 };
34
35 /* directories */
36
37 static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val,
38                                         size_t size)
39 {
40         return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs);
41 }
42
43 static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info *ci, char *val,
44                                       size_t size)
45 {
46         return snprintf(val, size, "%lld", ci->i_files);
47 }
48
49 static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info *ci, char *val,
50                                         size_t size)
51 {
52         return snprintf(val, size, "%lld", ci->i_subdirs);
53 }
54
55 static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info *ci, char *val,
56                                          size_t size)
57 {
58         return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs);
59 }
60
61 static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info *ci, char *val,
62                                        size_t size)
63 {
64         return snprintf(val, size, "%lld", ci->i_rfiles);
65 }
66
67 static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info *ci, char *val,
68                                          size_t size)
69 {
70         return snprintf(val, size, "%lld", ci->i_rsubdirs);
71 }
72
73 static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info *ci, char *val,
74                                        size_t size)
75 {
76         return snprintf(val, size, "%lld", ci->i_rbytes);
77 }
78
79 static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val,
80                                        size_t size)
81 {
82         return snprintf(val, size, "%ld.09%ld", (long)ci->i_rctime.tv_sec,
83                         (long)ci->i_rctime.tv_nsec);
84 }
85
86 #define CEPH_XATTR_NAME(_type, _name)   XATTR_CEPH_PREFIX #_type "." #_name
87
88 #define XATTR_NAME_CEPH(_type, _name) \
89                 { \
90                         .name = CEPH_XATTR_NAME(_type, _name), \
91                         .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
92                         .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
93                         .readonly = true, \
94                 }
95
96 static struct ceph_vxattr ceph_dir_vxattrs[] = {
97         XATTR_NAME_CEPH(dir, entries),
98         XATTR_NAME_CEPH(dir, files),
99         XATTR_NAME_CEPH(dir, subdirs),
100         XATTR_NAME_CEPH(dir, rentries),
101         XATTR_NAME_CEPH(dir, rfiles),
102         XATTR_NAME_CEPH(dir, rsubdirs),
103         XATTR_NAME_CEPH(dir, rbytes),
104         XATTR_NAME_CEPH(dir, rctime),
105         { 0 }   /* Required table terminator */
106 };
107 static size_t ceph_dir_vxattrs_name_size;       /* total size of all names */
108
109 /* files */
110
111 static size_t ceph_vxattrcb_file_layout(struct ceph_inode_info *ci, char *val,
112                                    size_t size)
113 {
114         int ret;
115
116         ret = snprintf(val, size,
117                 "chunk_bytes=%lld\nstripe_count=%lld\nobject_size=%lld\n",
118                 (unsigned long long)ceph_file_layout_su(ci->i_layout),
119                 (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout),
120                 (unsigned long long)ceph_file_layout_object_size(ci->i_layout));
121
122         if (ceph_file_layout_pg_preferred(ci->i_layout) >= 0) {
123                 val += ret;
124                 size -= ret;
125                 ret += snprintf(val, size, "preferred_osd=%lld\n",
126                             (unsigned long long)ceph_file_layout_pg_preferred(
127                                     ci->i_layout));
128         }
129
130         return ret;
131 }
132
133 static struct ceph_vxattr ceph_file_vxattrs[] = {
134         XATTR_NAME_CEPH(file, layout),
135         /* The following extended attribute name is deprecated */
136         {
137                 .name = XATTR_CEPH_PREFIX "layout",
138                 .name_size = sizeof (XATTR_CEPH_PREFIX "layout"),
139                 .getxattr_cb = ceph_vxattrcb_file_layout,
140                 .readonly = true,
141         },
142         { 0 }   /* Required table terminator */
143 };
144 static size_t ceph_file_vxattrs_name_size;      /* total size of all names */
145
146 static struct ceph_vxattr *ceph_inode_vxattrs(struct inode *inode)
147 {
148         if (S_ISDIR(inode->i_mode))
149                 return ceph_dir_vxattrs;
150         else if (S_ISREG(inode->i_mode))
151                 return ceph_file_vxattrs;
152         return NULL;
153 }
154
155 static size_t ceph_vxattrs_name_size(struct ceph_vxattr *vxattrs)
156 {
157         if (vxattrs == ceph_dir_vxattrs)
158                 return ceph_dir_vxattrs_name_size;
159         if (vxattrs == ceph_file_vxattrs)
160                 return ceph_file_vxattrs_name_size;
161         BUG();
162
163         return 0;
164 }
165
166 /*
167  * Compute the aggregate size (including terminating '\0') of all
168  * virtual extended attribute names in the given vxattr table.
169  */
170 static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs)
171 {
172         struct ceph_vxattr *vxattr;
173         size_t size = 0;
174
175         for (vxattr = vxattrs; vxattr->name; vxattr++)
176                 size += vxattr->name_size;
177
178         return size;
179 }
180
181 /* Routines called at initialization and exit time */
182
183 void __init ceph_xattr_init(void)
184 {
185         ceph_dir_vxattrs_name_size = vxattrs_name_size(ceph_dir_vxattrs);
186         ceph_file_vxattrs_name_size = vxattrs_name_size(ceph_file_vxattrs);
187 }
188
189 void ceph_xattr_exit(void)
190 {
191         ceph_dir_vxattrs_name_size = 0;
192         ceph_file_vxattrs_name_size = 0;
193 }
194
195 static struct ceph_vxattr *ceph_match_vxattr(struct inode *inode,
196                                                 const char *name)
197 {
198         struct ceph_vxattr *vxattr = ceph_inode_vxattrs(inode);
199
200         if (vxattr) {
201                 while (vxattr->name) {
202                         if (!strcmp(vxattr->name, name))
203                                 return vxattr;
204                         vxattr++;
205                 }
206         }
207
208         return NULL;
209 }
210
211 static int __set_xattr(struct ceph_inode_info *ci,
212                            const char *name, int name_len,
213                            const char *val, int val_len,
214                            int dirty,
215                            int should_free_name, int should_free_val,
216                            struct ceph_inode_xattr **newxattr)
217 {
218         struct rb_node **p;
219         struct rb_node *parent = NULL;
220         struct ceph_inode_xattr *xattr = NULL;
221         int c;
222         int new = 0;
223
224         p = &ci->i_xattrs.index.rb_node;
225         while (*p) {
226                 parent = *p;
227                 xattr = rb_entry(parent, struct ceph_inode_xattr, node);
228                 c = strncmp(name, xattr->name, min(name_len, xattr->name_len));
229                 if (c < 0)
230                         p = &(*p)->rb_left;
231                 else if (c > 0)
232                         p = &(*p)->rb_right;
233                 else {
234                         if (name_len == xattr->name_len)
235                                 break;
236                         else if (name_len < xattr->name_len)
237                                 p = &(*p)->rb_left;
238                         else
239                                 p = &(*p)->rb_right;
240                 }
241                 xattr = NULL;
242         }
243
244         if (!xattr) {
245                 new = 1;
246                 xattr = *newxattr;
247                 xattr->name = name;
248                 xattr->name_len = name_len;
249                 xattr->should_free_name = should_free_name;
250
251                 ci->i_xattrs.count++;
252                 dout("__set_xattr count=%d\n", ci->i_xattrs.count);
253         } else {
254                 kfree(*newxattr);
255                 *newxattr = NULL;
256                 if (xattr->should_free_val)
257                         kfree((void *)xattr->val);
258
259                 if (should_free_name) {
260                         kfree((void *)name);
261                         name = xattr->name;
262                 }
263                 ci->i_xattrs.names_size -= xattr->name_len;
264                 ci->i_xattrs.vals_size -= xattr->val_len;
265         }
266         ci->i_xattrs.names_size += name_len;
267         ci->i_xattrs.vals_size += val_len;
268         if (val)
269                 xattr->val = val;
270         else
271                 xattr->val = "";
272
273         xattr->val_len = val_len;
274         xattr->dirty = dirty;
275         xattr->should_free_val = (val && should_free_val);
276
277         if (new) {
278                 rb_link_node(&xattr->node, parent, p);
279                 rb_insert_color(&xattr->node, &ci->i_xattrs.index);
280                 dout("__set_xattr_val p=%p\n", p);
281         }
282
283         dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n",
284              ceph_vinop(&ci->vfs_inode), xattr, name, val_len, val);
285
286         return 0;
287 }
288
289 static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci,
290                            const char *name)
291 {
292         struct rb_node **p;
293         struct rb_node *parent = NULL;
294         struct ceph_inode_xattr *xattr = NULL;
295         int name_len = strlen(name);
296         int c;
297
298         p = &ci->i_xattrs.index.rb_node;
299         while (*p) {
300                 parent = *p;
301                 xattr = rb_entry(parent, struct ceph_inode_xattr, node);
302                 c = strncmp(name, xattr->name, xattr->name_len);
303                 if (c == 0 && name_len > xattr->name_len)
304                         c = 1;
305                 if (c < 0)
306                         p = &(*p)->rb_left;
307                 else if (c > 0)
308                         p = &(*p)->rb_right;
309                 else {
310                         dout("__get_xattr %s: found %.*s\n", name,
311                              xattr->val_len, xattr->val);
312                         return xattr;
313                 }
314         }
315
316         dout("__get_xattr %s: not found\n", name);
317
318         return NULL;
319 }
320
321 static void __free_xattr(struct ceph_inode_xattr *xattr)
322 {
323         BUG_ON(!xattr);
324
325         if (xattr->should_free_name)
326                 kfree((void *)xattr->name);
327         if (xattr->should_free_val)
328                 kfree((void *)xattr->val);
329
330         kfree(xattr);
331 }
332
333 static int __remove_xattr(struct ceph_inode_info *ci,
334                           struct ceph_inode_xattr *xattr)
335 {
336         if (!xattr)
337                 return -EOPNOTSUPP;
338
339         rb_erase(&xattr->node, &ci->i_xattrs.index);
340
341         if (xattr->should_free_name)
342                 kfree((void *)xattr->name);
343         if (xattr->should_free_val)
344                 kfree((void *)xattr->val);
345
346         ci->i_xattrs.names_size -= xattr->name_len;
347         ci->i_xattrs.vals_size -= xattr->val_len;
348         ci->i_xattrs.count--;
349         kfree(xattr);
350
351         return 0;
352 }
353
354 static int __remove_xattr_by_name(struct ceph_inode_info *ci,
355                            const char *name)
356 {
357         struct rb_node **p;
358         struct ceph_inode_xattr *xattr;
359         int err;
360
361         p = &ci->i_xattrs.index.rb_node;
362         xattr = __get_xattr(ci, name);
363         err = __remove_xattr(ci, xattr);
364         return err;
365 }
366
367 static char *__copy_xattr_names(struct ceph_inode_info *ci,
368                                 char *dest)
369 {
370         struct rb_node *p;
371         struct ceph_inode_xattr *xattr = NULL;
372
373         p = rb_first(&ci->i_xattrs.index);
374         dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count);
375
376         while (p) {
377                 xattr = rb_entry(p, struct ceph_inode_xattr, node);
378                 memcpy(dest, xattr->name, xattr->name_len);
379                 dest[xattr->name_len] = '\0';
380
381                 dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name,
382                      xattr->name_len, ci->i_xattrs.names_size);
383
384                 dest += xattr->name_len + 1;
385                 p = rb_next(p);
386         }
387
388         return dest;
389 }
390
391 void __ceph_destroy_xattrs(struct ceph_inode_info *ci)
392 {
393         struct rb_node *p, *tmp;
394         struct ceph_inode_xattr *xattr = NULL;
395
396         p = rb_first(&ci->i_xattrs.index);
397
398         dout("__ceph_destroy_xattrs p=%p\n", p);
399
400         while (p) {
401                 xattr = rb_entry(p, struct ceph_inode_xattr, node);
402                 tmp = p;
403                 p = rb_next(tmp);
404                 dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p,
405                      xattr->name_len, xattr->name);
406                 rb_erase(tmp, &ci->i_xattrs.index);
407
408                 __free_xattr(xattr);
409         }
410
411         ci->i_xattrs.names_size = 0;
412         ci->i_xattrs.vals_size = 0;
413         ci->i_xattrs.index_version = 0;
414         ci->i_xattrs.count = 0;
415         ci->i_xattrs.index = RB_ROOT;
416 }
417
418 static int __build_xattrs(struct inode *inode)
419         __releases(ci->i_ceph_lock)
420         __acquires(ci->i_ceph_lock)
421 {
422         u32 namelen;
423         u32 numattr = 0;
424         void *p, *end;
425         u32 len;
426         const char *name, *val;
427         struct ceph_inode_info *ci = ceph_inode(inode);
428         int xattr_version;
429         struct ceph_inode_xattr **xattrs = NULL;
430         int err = 0;
431         int i;
432
433         dout("__build_xattrs() len=%d\n",
434              ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0);
435
436         if (ci->i_xattrs.index_version >= ci->i_xattrs.version)
437                 return 0; /* already built */
438
439         __ceph_destroy_xattrs(ci);
440
441 start:
442         /* updated internal xattr rb tree */
443         if (ci->i_xattrs.blob && ci->i_xattrs.blob->vec.iov_len > 4) {
444                 p = ci->i_xattrs.blob->vec.iov_base;
445                 end = p + ci->i_xattrs.blob->vec.iov_len;
446                 ceph_decode_32_safe(&p, end, numattr, bad);
447                 xattr_version = ci->i_xattrs.version;
448                 spin_unlock(&ci->i_ceph_lock);
449
450                 xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *),
451                                  GFP_NOFS);
452                 err = -ENOMEM;
453                 if (!xattrs)
454                         goto bad_lock;
455                 memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *));
456                 for (i = 0; i < numattr; i++) {
457                         xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr),
458                                             GFP_NOFS);
459                         if (!xattrs[i])
460                                 goto bad_lock;
461                 }
462
463                 spin_lock(&ci->i_ceph_lock);
464                 if (ci->i_xattrs.version != xattr_version) {
465                         /* lost a race, retry */
466                         for (i = 0; i < numattr; i++)
467                                 kfree(xattrs[i]);
468                         kfree(xattrs);
469                         goto start;
470                 }
471                 err = -EIO;
472                 while (numattr--) {
473                         ceph_decode_32_safe(&p, end, len, bad);
474                         namelen = len;
475                         name = p;
476                         p += len;
477                         ceph_decode_32_safe(&p, end, len, bad);
478                         val = p;
479                         p += len;
480
481                         err = __set_xattr(ci, name, namelen, val, len,
482                                           0, 0, 0, &xattrs[numattr]);
483
484                         if (err < 0)
485                                 goto bad;
486                 }
487                 kfree(xattrs);
488         }
489         ci->i_xattrs.index_version = ci->i_xattrs.version;
490         ci->i_xattrs.dirty = false;
491
492         return err;
493 bad_lock:
494         spin_lock(&ci->i_ceph_lock);
495 bad:
496         if (xattrs) {
497                 for (i = 0; i < numattr; i++)
498                         kfree(xattrs[i]);
499                 kfree(xattrs);
500         }
501         ci->i_xattrs.names_size = 0;
502         return err;
503 }
504
505 static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size,
506                                     int val_size)
507 {
508         /*
509          * 4 bytes for the length, and additional 4 bytes per each xattr name,
510          * 4 bytes per each value
511          */
512         int size = 4 + ci->i_xattrs.count*(4 + 4) +
513                              ci->i_xattrs.names_size +
514                              ci->i_xattrs.vals_size;
515         dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n",
516              ci->i_xattrs.count, ci->i_xattrs.names_size,
517              ci->i_xattrs.vals_size);
518
519         if (name_size)
520                 size += 4 + 4 + name_size + val_size;
521
522         return size;
523 }
524
525 /*
526  * If there are dirty xattrs, reencode xattrs into the prealloc_blob
527  * and swap into place.
528  */
529 void __ceph_build_xattrs_blob(struct ceph_inode_info *ci)
530 {
531         struct rb_node *p;
532         struct ceph_inode_xattr *xattr = NULL;
533         void *dest;
534
535         dout("__build_xattrs_blob %p\n", &ci->vfs_inode);
536         if (ci->i_xattrs.dirty) {
537                 int need = __get_required_blob_size(ci, 0, 0);
538
539                 BUG_ON(need > ci->i_xattrs.prealloc_blob->alloc_len);
540
541                 p = rb_first(&ci->i_xattrs.index);
542                 dest = ci->i_xattrs.prealloc_blob->vec.iov_base;
543
544                 ceph_encode_32(&dest, ci->i_xattrs.count);
545                 while (p) {
546                         xattr = rb_entry(p, struct ceph_inode_xattr, node);
547
548                         ceph_encode_32(&dest, xattr->name_len);
549                         memcpy(dest, xattr->name, xattr->name_len);
550                         dest += xattr->name_len;
551                         ceph_encode_32(&dest, xattr->val_len);
552                         memcpy(dest, xattr->val, xattr->val_len);
553                         dest += xattr->val_len;
554
555                         p = rb_next(p);
556                 }
557
558                 /* adjust buffer len; it may be larger than we need */
559                 ci->i_xattrs.prealloc_blob->vec.iov_len =
560                         dest - ci->i_xattrs.prealloc_blob->vec.iov_base;
561
562                 if (ci->i_xattrs.blob)
563                         ceph_buffer_put(ci->i_xattrs.blob);
564                 ci->i_xattrs.blob = ci->i_xattrs.prealloc_blob;
565                 ci->i_xattrs.prealloc_blob = NULL;
566                 ci->i_xattrs.dirty = false;
567                 ci->i_xattrs.version++;
568         }
569 }
570
571 ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
572                       size_t size)
573 {
574         struct inode *inode = dentry->d_inode;
575         struct ceph_inode_info *ci = ceph_inode(inode);
576         int err;
577         struct ceph_inode_xattr *xattr;
578         struct ceph_vxattr *vxattr = NULL;
579
580         if (!ceph_is_valid_xattr(name))
581                 return -ENODATA;
582
583         /* let's see if a virtual xattr was requested */
584         vxattr = ceph_match_vxattr(inode, name);
585
586         spin_lock(&ci->i_ceph_lock);
587         dout("getxattr %p ver=%lld index_ver=%lld\n", inode,
588              ci->i_xattrs.version, ci->i_xattrs.index_version);
589
590         if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) &&
591             (ci->i_xattrs.index_version >= ci->i_xattrs.version)) {
592                 goto get_xattr;
593         } else {
594                 spin_unlock(&ci->i_ceph_lock);
595                 /* get xattrs from mds (if we don't already have them) */
596                 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR);
597                 if (err)
598                         return err;
599         }
600
601         spin_lock(&ci->i_ceph_lock);
602
603         if (vxattr && vxattr->readonly) {
604                 err = vxattr->getxattr_cb(ci, value, size);
605                 goto out;
606         }
607
608         err = __build_xattrs(inode);
609         if (err < 0)
610                 goto out;
611
612 get_xattr:
613         err = -ENODATA;  /* == ENOATTR */
614         xattr = __get_xattr(ci, name);
615         if (!xattr) {
616                 if (vxattr)
617                         err = vxattr->getxattr_cb(ci, value, size);
618                 goto out;
619         }
620
621         err = -ERANGE;
622         if (size && size < xattr->val_len)
623                 goto out;
624
625         err = xattr->val_len;
626         if (size == 0)
627                 goto out;
628
629         memcpy(value, xattr->val, xattr->val_len);
630
631 out:
632         spin_unlock(&ci->i_ceph_lock);
633         return err;
634 }
635
636 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
637 {
638         struct inode *inode = dentry->d_inode;
639         struct ceph_inode_info *ci = ceph_inode(inode);
640         struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode);
641         u32 vir_namelen = 0;
642         u32 namelen;
643         int err;
644         u32 len;
645         int i;
646
647         spin_lock(&ci->i_ceph_lock);
648         dout("listxattr %p ver=%lld index_ver=%lld\n", inode,
649              ci->i_xattrs.version, ci->i_xattrs.index_version);
650
651         if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) &&
652             (ci->i_xattrs.index_version >= ci->i_xattrs.version)) {
653                 goto list_xattr;
654         } else {
655                 spin_unlock(&ci->i_ceph_lock);
656                 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR);
657                 if (err)
658                         return err;
659         }
660
661         spin_lock(&ci->i_ceph_lock);
662
663         err = __build_xattrs(inode);
664         if (err < 0)
665                 goto out;
666
667 list_xattr:
668         /*
669          * Start with virtual dir xattr names (if any) (including
670          * terminating '\0' characters for each).
671          */
672         vir_namelen = ceph_vxattrs_name_size(vxattrs);
673
674         /* adding 1 byte per each variable due to the null termination */
675         namelen = vir_namelen + ci->i_xattrs.names_size + ci->i_xattrs.count;
676         err = -ERANGE;
677         if (size && namelen > size)
678                 goto out;
679
680         err = namelen;
681         if (size == 0)
682                 goto out;
683
684         names = __copy_xattr_names(ci, names);
685
686         /* virtual xattr names, too */
687         if (vxattrs)
688                 for (i = 0; vxattrs[i].name; i++) {
689                         len = sprintf(names, "%s", vxattrs[i].name);
690                         names += len + 1;
691                 }
692
693 out:
694         spin_unlock(&ci->i_ceph_lock);
695         return err;
696 }
697
698 static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
699                               const char *value, size_t size, int flags)
700 {
701         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
702         struct inode *inode = dentry->d_inode;
703         struct ceph_inode_info *ci = ceph_inode(inode);
704         struct inode *parent_inode;
705         struct ceph_mds_request *req;
706         struct ceph_mds_client *mdsc = fsc->mdsc;
707         int err;
708         int i, nr_pages;
709         struct page **pages = NULL;
710         void *kaddr;
711
712         /* copy value into some pages */
713         nr_pages = calc_pages_for(0, size);
714         if (nr_pages) {
715                 pages = kmalloc(sizeof(pages[0])*nr_pages, GFP_NOFS);
716                 if (!pages)
717                         return -ENOMEM;
718                 err = -ENOMEM;
719                 for (i = 0; i < nr_pages; i++) {
720                         pages[i] = __page_cache_alloc(GFP_NOFS);
721                         if (!pages[i]) {
722                                 nr_pages = i;
723                                 goto out;
724                         }
725                         kaddr = kmap(pages[i]);
726                         memcpy(kaddr, value + i*PAGE_CACHE_SIZE,
727                                min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE));
728                 }
729         }
730
731         dout("setxattr value=%.*s\n", (int)size, value);
732
733         /* do request */
734         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETXATTR,
735                                        USE_AUTH_MDS);
736         if (IS_ERR(req)) {
737                 err = PTR_ERR(req);
738                 goto out;
739         }
740         req->r_inode = inode;
741         ihold(inode);
742         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
743         req->r_num_caps = 1;
744         req->r_args.setxattr.flags = cpu_to_le32(flags);
745         req->r_path2 = kstrdup(name, GFP_NOFS);
746
747         req->r_pages = pages;
748         req->r_num_pages = nr_pages;
749         req->r_data_len = size;
750
751         dout("xattr.ver (before): %lld\n", ci->i_xattrs.version);
752         parent_inode = ceph_get_dentry_parent_inode(dentry);
753         err = ceph_mdsc_do_request(mdsc, parent_inode, req);
754         iput(parent_inode);
755         ceph_mdsc_put_request(req);
756         dout("xattr.ver (after): %lld\n", ci->i_xattrs.version);
757
758 out:
759         if (pages) {
760                 for (i = 0; i < nr_pages; i++)
761                         __free_page(pages[i]);
762                 kfree(pages);
763         }
764         return err;
765 }
766
767 int ceph_setxattr(struct dentry *dentry, const char *name,
768                   const void *value, size_t size, int flags)
769 {
770         struct inode *inode = dentry->d_inode;
771         struct ceph_vxattr *vxattr;
772         struct ceph_inode_info *ci = ceph_inode(inode);
773         int issued;
774         int err;
775         int dirty;
776         int name_len = strlen(name);
777         int val_len = size;
778         char *newname = NULL;
779         char *newval = NULL;
780         struct ceph_inode_xattr *xattr = NULL;
781         int required_blob_size;
782
783         if (ceph_snap(inode) != CEPH_NOSNAP)
784                 return -EROFS;
785
786         if (!ceph_is_valid_xattr(name))
787                 return -EOPNOTSUPP;
788
789         vxattr = ceph_match_vxattr(inode, name);
790         if (vxattr && vxattr->readonly)
791                 return -EOPNOTSUPP;
792
793         /* preallocate memory for xattr name, value, index node */
794         err = -ENOMEM;
795         newname = kmemdup(name, name_len + 1, GFP_NOFS);
796         if (!newname)
797                 goto out;
798
799         if (val_len) {
800                 newval = kmemdup(value, val_len, GFP_NOFS);
801                 if (!newval)
802                         goto out;
803         }
804
805         xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS);
806         if (!xattr)
807                 goto out;
808
809         spin_lock(&ci->i_ceph_lock);
810 retry:
811         issued = __ceph_caps_issued(ci, NULL);
812         dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued));
813         if (!(issued & CEPH_CAP_XATTR_EXCL))
814                 goto do_sync;
815         __build_xattrs(inode);
816
817         required_blob_size = __get_required_blob_size(ci, name_len, val_len);
818
819         if (!ci->i_xattrs.prealloc_blob ||
820             required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) {
821                 struct ceph_buffer *blob;
822
823                 spin_unlock(&ci->i_ceph_lock);
824                 dout(" preaallocating new blob size=%d\n", required_blob_size);
825                 blob = ceph_buffer_new(required_blob_size, GFP_NOFS);
826                 if (!blob)
827                         goto out;
828                 spin_lock(&ci->i_ceph_lock);
829                 if (ci->i_xattrs.prealloc_blob)
830                         ceph_buffer_put(ci->i_xattrs.prealloc_blob);
831                 ci->i_xattrs.prealloc_blob = blob;
832                 goto retry;
833         }
834
835         err = __set_xattr(ci, newname, name_len, newval,
836                           val_len, 1, 1, 1, &xattr);
837
838         dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL);
839         ci->i_xattrs.dirty = true;
840         inode->i_ctime = CURRENT_TIME;
841
842         spin_unlock(&ci->i_ceph_lock);
843         if (dirty)
844                 __mark_inode_dirty(inode, dirty);
845         return err;
846
847 do_sync:
848         spin_unlock(&ci->i_ceph_lock);
849         err = ceph_sync_setxattr(dentry, name, value, size, flags);
850 out:
851         kfree(newname);
852         kfree(newval);
853         kfree(xattr);
854         return err;
855 }
856
857 static int ceph_send_removexattr(struct dentry *dentry, const char *name)
858 {
859         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
860         struct ceph_mds_client *mdsc = fsc->mdsc;
861         struct inode *inode = dentry->d_inode;
862         struct inode *parent_inode;
863         struct ceph_mds_request *req;
864         int err;
865
866         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RMXATTR,
867                                        USE_AUTH_MDS);
868         if (IS_ERR(req))
869                 return PTR_ERR(req);
870         req->r_inode = inode;
871         ihold(inode);
872         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
873         req->r_num_caps = 1;
874         req->r_path2 = kstrdup(name, GFP_NOFS);
875
876         parent_inode = ceph_get_dentry_parent_inode(dentry);
877         err = ceph_mdsc_do_request(mdsc, parent_inode, req);
878         iput(parent_inode);
879         ceph_mdsc_put_request(req);
880         return err;
881 }
882
883 int ceph_removexattr(struct dentry *dentry, const char *name)
884 {
885         struct inode *inode = dentry->d_inode;
886         struct ceph_vxattr *vxattr;
887         struct ceph_inode_info *ci = ceph_inode(inode);
888         int issued;
889         int err;
890         int required_blob_size;
891         int dirty;
892
893         if (ceph_snap(inode) != CEPH_NOSNAP)
894                 return -EROFS;
895
896         if (!ceph_is_valid_xattr(name))
897                 return -EOPNOTSUPP;
898
899         vxattr = ceph_match_vxattr(inode, name);
900         if (vxattr && vxattr->readonly)
901                 return -EOPNOTSUPP;
902
903         err = -ENOMEM;
904         spin_lock(&ci->i_ceph_lock);
905 retry:
906         issued = __ceph_caps_issued(ci, NULL);
907         dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued));
908
909         if (!(issued & CEPH_CAP_XATTR_EXCL))
910                 goto do_sync;
911         __build_xattrs(inode);
912
913         required_blob_size = __get_required_blob_size(ci, 0, 0);
914
915         if (!ci->i_xattrs.prealloc_blob ||
916             required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) {
917                 struct ceph_buffer *blob;
918
919                 spin_unlock(&ci->i_ceph_lock);
920                 dout(" preaallocating new blob size=%d\n", required_blob_size);
921                 blob = ceph_buffer_new(required_blob_size, GFP_NOFS);
922                 if (!blob)
923                         goto out;
924                 spin_lock(&ci->i_ceph_lock);
925                 if (ci->i_xattrs.prealloc_blob)
926                         ceph_buffer_put(ci->i_xattrs.prealloc_blob);
927                 ci->i_xattrs.prealloc_blob = blob;
928                 goto retry;
929         }
930
931         err = __remove_xattr_by_name(ceph_inode(inode), name);
932
933         dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL);
934         ci->i_xattrs.dirty = true;
935         inode->i_ctime = CURRENT_TIME;
936         spin_unlock(&ci->i_ceph_lock);
937         if (dirty)
938                 __mark_inode_dirty(inode, dirty);
939         return err;
940 do_sync:
941         spin_unlock(&ci->i_ceph_lock);
942         err = ceph_send_removexattr(dentry, name);
943 out:
944         return err;
945 }
946