~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ceph/xattr.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp