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

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

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

~ [ 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