Bug Summary

File:xlators/system/posix-acl/src/posix-acl.c
Location:line 1107, column 9
Description:Value stored to 'newmode' is never read

Annotated Source Code

1/*
2 Copyright (c) 2011-2012 Red Hat, Inc. <http://www.redhat.com>
3 This file is part of GlusterFS.
4
5 This file is licensed to you under your choice of the GNU Lesser
6 General Public License, version 3 or any later version (LGPLv3 or
7 later), or the GNU General Public License, version 2 (GPLv2), in all
8 cases as published by the Free Software Foundation.
9*/
10
11#include <errno(*__errno_location ()).h>
12
13#include "xlator.h"
14#include "glusterfs.h"
15
16#include "posix-acl.h"
17#include "posix-acl-xattr.h"
18
19
20#define UINT64(ptr)((uint64_t)((long)(ptr))) ((uint64_t)((long)(ptr)))
21#define PTR(num)((void *)((long)(num))) ((void *)((long)(num)))
22
23
24static uid_t
25r00t ()
26{
27 struct posix_acl_conf *conf = NULL((void*)0);
28
29 conf = THIS(*__glusterfs_this_location())->private;
30
31 return conf->super_uid;
32}
33
34
35int
36whitelisted_xattr (const char *key)
37{
38 if (!key)
39 return 0;
40
41 if (strcmp (POSIX_ACL_ACCESS_XATTR"system.posix_acl_access", key) == 0)
42 return 1;
43 if (strcmp (POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default", key) == 0)
44 return 1;
45 return 0;
46}
47
48
49int
50frame_is_user (call_frame_t *frame, uid_t uid)
51{
52 return (frame->root->uid == uid);
53}
54
55
56int
57frame_is_super_user (call_frame_t *frame)
58{
59 int ret;
60
61 ret = frame_is_user (frame, r00t());
62 if (!ret)
63 ret = frame_is_user (frame, 0);
64
65 return ret;
66}
67
68
69int
70frame_in_group (call_frame_t *frame, gid_t gid)
71{
72 int i = 0;
73
74 if (frame->root->gid == gid)
75 return 1;
76
77 for (i = 0; i < frame->root->ngrps; i++)
78 if (frame->root->groups[i] == gid)
79 return 1;
80 return 0;
81}
82
83
84mode_t
85posix_acl_access_set_mode (struct posix_acl *acl, struct posix_acl_ctx *ctx)
86{
87 struct posix_ace *ace = NULL((void*)0);
88 struct posix_ace *group_ce = NULL((void*)0);
89 struct posix_ace *mask_ce = NULL((void*)0);
90 int count = 0;
91 int i = 0;
92 mode_t mode = 0;
93 int mask = 0;
94
95 count = acl->count;
96
97 ace = acl->entries;
98 for (i = 0; i < count; i++) {
99 switch (ace->tag) {
100 case POSIX_ACL_USER_OBJ(0x01):
101 mask |= S_IRWXU(0400|0200|0100);
102 mode |= (ace->perm << 6);
103 break;
104 case POSIX_ACL_GROUP_OBJ(0x04):
105 group_ce = ace;
106 break;
107 case POSIX_ACL_MASK(0x10):
108 mask_ce = ace;
109 break;
110 case POSIX_ACL_OTHER(0x20):
111 mask |= S_IRWXO(((0400|0200|0100) >> 3) >> 3);
112 mode |= (ace->perm);
113 break;
114 }
115 ace++;
116 }
117
118 if (mask_ce) {
119 mask |= S_IRWXG((0400|0200|0100) >> 3);
120 mode |= (mask_ce->perm << 3);
121 } else {
122 if (!group_ce)
123 goto out;
124 mask |= S_IRWXG((0400|0200|0100) >> 3);
125 mode |= (group_ce->perm << 3);
126 }
127
128out:
129 ctx->perm = (ctx->perm & ~mask) | mode;
130
131 return mode;
132}
133
134
135static int
136sticky_permits (call_frame_t *frame, inode_t *parent, inode_t *inode)
137{
138 struct posix_acl_ctx *par = NULL((void*)0);
139 struct posix_acl_ctx *ctx = NULL((void*)0);
140
141 par = posix_acl_ctx_get (parent, frame->this);
142 ctx = posix_acl_ctx_get (inode, frame->this);
143
144 if (frame_is_super_user (frame))
145 return 1;
146
147 if (!(par->perm & S_ISVTX01000))
148 return 1;
149
150 if (frame_is_user (frame, par->uid))
151 return 1;
152
153 if (frame_is_user (frame, ctx->uid))
154 return 1;
155
156 return 0;
157}
158
159
160static int
161acl_permits (call_frame_t *frame, inode_t *inode, int want)
162{
163 int verdict = 0;
164 struct posix_acl *acl = NULL((void*)0);
165 struct posix_ace *ace = NULL((void*)0);
166 struct posix_acl_ctx *ctx = NULL((void*)0);
167 struct posix_acl_conf *conf = NULL((void*)0);
168 int i = 0;
169 int perm = 0;
170 int found = 0;
171 int acl_present = 0;
172
173 conf = frame->this->private;
174
175 ctx = posix_acl_ctx_get (inode, frame->this);
176 if (!ctx)
177 goto red;
178
179 if (frame_is_super_user (frame))
180 goto green;
181
182 posix_acl_get (inode, frame->this, &acl, NULL((void*)0));
183 if (!acl) {
184 acl = posix_acl_ref (frame->this, conf->minimal_acl);
185 }
186
187 ace = acl->entries;
188
189 if (acl->count > 3)
190 acl_present = 1;
191
192 for (i = 0; i < acl->count; i++) {
193 switch (ace->tag) {
194 case POSIX_ACL_USER_OBJ(0x01):
195 perm = ((ctx->perm & S_IRWXU(0400|0200|0100)) >> 6);
196 if (frame_is_user (frame, ctx->uid))
197 goto perm_check;
198 break;
199 case POSIX_ACL_USER(0x02):
200 perm = ace->perm;
201 if (frame_is_user (frame, ace->id))
202 goto mask_check;
203 break;
204 case POSIX_ACL_GROUP_OBJ(0x04):
205 if (acl_present)
206 perm = ace->perm;
207 else
208 perm = ((ctx->perm & S_IRWXG((0400|0200|0100) >> 3)) >> 3);
209 if (frame_in_group (frame, ctx->gid)) {
210 found = 1;
211 if ((perm & want) == want)
212 goto mask_check;
213 }
214 break;
215 case POSIX_ACL_GROUP(0x08):
216 perm = ace->perm;
217 if (frame_in_group (frame, ace->id)) {
218 found = 1;
219 if ((perm & want) == want)
220 goto mask_check;
221 }
222 break;
223 case POSIX_ACL_MASK(0x10):
224 break;
225 case POSIX_ACL_OTHER(0x20):
226 perm = (ctx->perm & S_IRWXO(((0400|0200|0100) >> 3) >> 3));
227 if (!found)
228 goto perm_check;
229 /* fall through */
230 default:
231 goto red;
232 }
233
234 ace++;
235 }
236
237mask_check:
238 ace = acl->entries;
239
240 for (i = 0; i < acl->count; i++, ace++) {
241 if (ace->tag != POSIX_ACL_MASK(0x10))
242 continue;
243 if ((ace->perm & perm & want) == want) {
244 goto green;
245 }
246 goto red;
247 }
248
249perm_check:
250 if ((perm & want) == want) {
251 goto green;
252 } else {
253 goto red;
254 }
255
256green:
257 verdict = 1;
258 goto out;
259red:
260 verdict = 0;
261out:
262 if (acl)
263 posix_acl_unref (frame->this, acl);
264
265 return verdict;
266}
267
268
269struct posix_acl_ctx *
270posix_acl_ctx_get (inode_t *inode, xlator_t *this)
271{
272 struct posix_acl_ctx *ctx = NULL((void*)0);
273 uint64_t int_ctx = 0;
274 int ret = 0;
275
276 ret = inode_ctx_get (inode, this, &int_ctx)inode_ctx_get2(inode,this,&int_ctx,0);
277 if ((ret == 0) && (int_ctx))
278 return PTR(int_ctx)((void *)((long)(int_ctx)));
279
280 ctx = CALLOC (1, sizeof (*ctx))__gf_default_calloc(1,sizeof (*ctx));
281 if (!ctx)
282 return NULL((void*)0);
283
284 ret = inode_ctx_put (inode, this, UINT64 (ctx)((uint64_t)((long)(ctx))));
285
286 return ctx;
287}
288
289
290int
291__posix_acl_set (inode_t *inode, xlator_t *this, struct posix_acl *acl_access,
292 struct posix_acl *acl_default)
293{
294 int ret = 0;
295 struct posix_acl_ctx *ctx = NULL((void*)0);
296
297 ctx = posix_acl_ctx_get (inode, this);
298 if (!ctx)
299 goto out;
300
301 ctx->acl_access = acl_access;
302 ctx->acl_default = acl_default;
303
304out:
305 return ret;
306}
307
308
309int
310__posix_acl_get (inode_t *inode, xlator_t *this, struct posix_acl **acl_access_p,
311 struct posix_acl **acl_default_p)
312{
313 int ret = 0;
314 struct posix_acl_ctx *ctx = NULL((void*)0);
315
316 ctx = posix_acl_ctx_get (inode, this);
317 if (!ctx)
318 goto out;
319
320 if (acl_access_p)
321 *acl_access_p = ctx->acl_access;
322 if (acl_default_p)
323 *acl_default_p = ctx->acl_default;
324
325out:
326 return ret;
327}
328
329
330struct posix_acl *
331posix_acl_new (xlator_t *this, int entrycnt)
332{
333 struct posix_acl *acl = NULL((void*)0);
334 struct posix_ace *ace = NULL((void*)0);
335
336 acl = CALLOC (1, sizeof (*acl) + (entrycnt * sizeof (*ace)))__gf_default_calloc(1,sizeof (*acl) + (entrycnt * sizeof (*ace
)))
;
337 if (!acl)
338 return NULL((void*)0);
339
340 acl->count = entrycnt;
341
342 posix_acl_ref (this, acl);
343
344 return acl;
345}
346
347
348void
349posix_acl_destroy (xlator_t *this, struct posix_acl *acl)
350{
351 FREE (acl)if (acl != ((void*)0)) { free ((void *)acl); acl = (void *)0xeeeeeeee
; }
;
352
353 return;
354}
355
356
357struct posix_acl *
358posix_acl_ref (xlator_t *this, struct posix_acl *acl)
359{
360 struct posix_acl_conf *conf = NULL((void*)0);
361
362 conf = this->private;
363
364 LOCK(&conf->acl_lock)pthread_spin_lock (&conf->acl_lock);
365 {
366 acl->refcnt++;
367 }
368 UNLOCK(&conf->acl_lock)pthread_spin_unlock (&conf->acl_lock);
369
370 return acl;
371}
372
373
374struct posix_acl *
375posix_acl_dup (xlator_t *this, struct posix_acl *acl)
376{
377 struct posix_acl *dup = NULL((void*)0);
378
379 dup = posix_acl_new (this, acl->count);
380 if (!dup)
381 return NULL((void*)0);
382
383 memcpy (dup->entries, acl->entries,
384 sizeof (struct posix_ace) * acl->count);
385
386 return dup;
387}
388
389
390void
391posix_acl_unref (xlator_t *this, struct posix_acl *acl)
392{
393 struct posix_acl_conf *conf = NULL((void*)0);
394 int refcnt = 0;
395
396 conf = this->private;
397
398 LOCK(&conf->acl_lock)pthread_spin_lock (&conf->acl_lock);
399 {
400 refcnt = --acl->refcnt;
401 }
402 UNLOCK(&conf->acl_lock)pthread_spin_unlock (&conf->acl_lock);
403
404 if (!refcnt)
405 posix_acl_destroy (this, acl);
406}
407
408
409int
410posix_acl_set (inode_t *inode, xlator_t *this, struct posix_acl *acl_access,
411 struct posix_acl *acl_default)
412{
413 int ret = 0;
414 int oldret = 0;
415 struct posix_acl *old_access = NULL((void*)0);
416 struct posix_acl *old_default = NULL((void*)0);
417 struct posix_acl_conf *conf = NULL((void*)0);
418
419 conf = this->private;
420
421 LOCK(&conf->acl_lock)pthread_spin_lock (&conf->acl_lock);
422 {
423 oldret = __posix_acl_get (inode, this, &old_access,
424 &old_default);
425 if (acl_access)
426 acl_access->refcnt++;
427 if (acl_default)
428 acl_default->refcnt++;
429
430 ret = __posix_acl_set (inode, this, acl_access, acl_default);
431 }
432 UNLOCK(&conf->acl_lock)pthread_spin_unlock (&conf->acl_lock);
433
434 if (oldret == 0) {
435 if (old_access)
436 posix_acl_unref (this, old_access);
437 if (old_default)
438 posix_acl_unref (this, old_default);
439 }
440
441 return ret;
442}
443
444
445int
446posix_acl_get (inode_t *inode, xlator_t *this, struct posix_acl **acl_access_p,
447 struct posix_acl **acl_default_p)
448{
449 struct posix_acl_conf *conf = NULL((void*)0);
450 struct posix_acl *acl_access = NULL((void*)0);
451 struct posix_acl *acl_default = NULL((void*)0);
452 int ret = 0;
453
454 conf = this->private;
455
456 LOCK(&conf->acl_lock)pthread_spin_lock (&conf->acl_lock);
457 {
458 ret = __posix_acl_get (inode, this, &acl_access, &acl_default);
459
460 if (ret != 0)
461 goto unlock;
462
463 if (acl_access && acl_access_p)
464 acl_access->refcnt++;
465 if (acl_default && acl_default_p)
466 acl_default->refcnt++;
467 }
468unlock:
469 UNLOCK(&conf->acl_lock)pthread_spin_unlock (&conf->acl_lock);
470
471 if (acl_access_p)
472 *acl_access_p = acl_access;
473 if (acl_default_p)
474 *acl_default_p = acl_default;
475
476 return ret;
477}
478
479
480mode_t
481posix_acl_inherit_mode (struct posix_acl *acl, mode_t modein)
482{
483 struct posix_ace *ace = NULL((void*)0);
484 int count = 0;
485 int i = 0;
486 mode_t newmode = 0;
487 mode_t mode = 0;
488 struct posix_ace *mask_ce = NULL((void*)0);
489 struct posix_ace *group_ce = NULL((void*)0);
490
491 newmode = mode = modein;
492
493 count = acl->count;
494
495 ace = acl->entries;
496 for (i = 0; i < count; i++) {
497 switch (ace->tag) {
498 case POSIX_ACL_USER_OBJ(0x01):
499 ace->perm &= (mode >> 6) | ~S_IRWXO(((0400|0200|0100) >> 3) >> 3);
500 mode &= (ace->perm << 6) | ~S_IRWXU(0400|0200|0100);
501 break;
502 case POSIX_ACL_GROUP_OBJ(0x04):
503 group_ce = ace;
504 break;
505 case POSIX_ACL_MASK(0x10):
506 mask_ce = ace;
507 break;
508 case POSIX_ACL_OTHER(0x20):
509 ace->perm &= (mode) | ~S_IRWXO(((0400|0200|0100) >> 3) >> 3);
510 mode &= (ace->perm) | ~S_IRWXO(((0400|0200|0100) >> 3) >> 3);
511 break;
512 }
513 ace++;
514 }
515
516 if (mask_ce) {
517 mask_ce->perm &= (mode >> 3) | ~S_IRWXO(((0400|0200|0100) >> 3) >> 3);
518 mode &= (mask_ce->perm << 3) | ~S_IRWXG((0400|0200|0100) >> 3);
519 } else if (group_ce) {
520 group_ce->perm &= (mode >> 3) | ~S_IRWXO(((0400|0200|0100) >> 3) >> 3);
521 mode &= (group_ce->perm << 3) | ~S_IRWXG((0400|0200|0100) >> 3);
522 }
523
524 newmode = ((modein & (S_IFMT0170000 | S_ISUID04000 | S_ISGID02000 | S_ISVTX01000)) |
525 (mode & (S_IRWXU(0400|0200|0100)|S_IRWXG((0400|0200|0100) >> 3)|S_IRWXO(((0400|0200|0100) >> 3) >> 3))));
526
527 return newmode;
528}
529
530
531mode_t
532posix_acl_inherit (xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
533 int32_t umask, int is_dir)
534{
535 int ret = 0;
536 struct posix_acl *par_default = NULL((void*)0);
537 struct posix_acl *acl_default = NULL((void*)0);
538 struct posix_acl *acl_access = NULL((void*)0);
539 struct posix_acl_ctx *ctx = NULL((void*)0);
540 char *xattr_default = NULL((void*)0);
541 char *xattr_access = NULL((void*)0);
542 int size_default = 0;
543 int size_access = 0;
544 mode_t retmode = 0;
545 int16_t tmp_mode = 0;
546 mode_t client_umask = 0;
547
548 retmode = mode;
549 client_umask = umask;
550 ret = dict_get_int16 (params, "umask", &tmp_mode);
551 if (ret == 0) {
552 client_umask = (mode_t)tmp_mode;
553 dict_del (params, "umask");
554 ret = dict_get_int16 (params, "mode", &tmp_mode);
555 if (ret == 0) {
556 retmode = (mode_t)tmp_mode;
557 dict_del (params, "mode");
558 } else {
559 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("client sent umask, but not the original mode"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 560, GF_LOG_ERROR, "client sent umask, but not the original mode"
); } while (0)
560 "client sent umask, but not the original mode")do { do { if (0) printf ("client sent umask, but not the original mode"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 560, GF_LOG_ERROR, "client sent umask, but not the original mode"
); } while (0)
;
561 }
562 }
563
564 ret = posix_acl_get (loc->parent, this, NULL((void*)0), &par_default);
565
566 if (!par_default)
567 goto out;
568
569 ctx = posix_acl_ctx_get (loc->inode, this);
570
571 acl_access = posix_acl_dup (this, par_default);
572 if (!acl_access)
573 goto out;
574
575 client_umask = 0; // No umask if we inherit an ACL
576 retmode = posix_acl_inherit_mode (acl_access, retmode);
577 ctx->perm = retmode;
578
579 size_access = posix_acl_to_xattr (this, acl_access, NULL((void*)0), 0);
580 xattr_access = CALLOC (1, size_access)__gf_default_calloc(1,size_access);
581 if (!xattr_access) {
582 gf_log (this->name, GF_LOG_ERROR, "out of memory")do { do { if (0) printf ("out of memory"); } while (0); _gf_log
(this->name, "posix-acl.c", __FUNCTION__, 582, GF_LOG_ERROR
, "out of memory"); } while (0)
;
583 ret = -1;
584 goto out;
585 }
586 posix_acl_to_xattr (this, acl_access, xattr_access, size_access);
587
588 ret = dict_set_bin (params, POSIX_ACL_ACCESS_XATTR"system.posix_acl_access", xattr_access,
589 size_access);
590 if (ret) {
591 gf_log (this->name, GF_LOG_ERROR, "out of memory")do { do { if (0) printf ("out of memory"); } while (0); _gf_log
(this->name, "posix-acl.c", __FUNCTION__, 591, GF_LOG_ERROR
, "out of memory"); } while (0)
;
592 ret = -1;
593 goto out;
594 }
595
596 if (!is_dir)
597 goto set;
598
599
600 acl_default = posix_acl_ref (this, par_default);
601
602 size_default = posix_acl_to_xattr (this, acl_default, NULL((void*)0), 0);
603 xattr_default = CALLOC (1, size_default)__gf_default_calloc(1,size_default);
604 if (!xattr_default) {
605 gf_log (this->name, GF_LOG_ERROR, "out of memory")do { do { if (0) printf ("out of memory"); } while (0); _gf_log
(this->name, "posix-acl.c", __FUNCTION__, 605, GF_LOG_ERROR
, "out of memory"); } while (0)
;
606 ret = -1;
607 goto out;
608 }
609 posix_acl_to_xattr (this, acl_default, xattr_default, size_default);
610
611 ret = dict_set_bin (params, POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default", xattr_default,
612 size_default);
613 if (ret) {
614 gf_log (this->name, GF_LOG_ERROR, "out of memory")do { do { if (0) printf ("out of memory"); } while (0); _gf_log
(this->name, "posix-acl.c", __FUNCTION__, 614, GF_LOG_ERROR
, "out of memory"); } while (0)
;
615 ret = -1;
616 goto out;
617 }
618
619set:
620 ret = posix_acl_set (loc->inode, this, acl_access, acl_default);
621 if (ret != 0)
622 goto out;
623
624out:
625 retmode &= ~client_umask;
626
627 if (par_default)
628 posix_acl_unref (this, par_default);
629 if (acl_access)
630 posix_acl_unref (this, acl_access);
631 if (acl_default)
632 posix_acl_unref (this, acl_default);
633
634 return retmode;
635}
636
637
638mode_t
639posix_acl_inherit_dir (xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
640 int32_t umask)
641{
642 mode_t retmode = 0;
643
644 retmode = posix_acl_inherit (this, loc, params, mode, umask, 1);
645
646 return retmode;
647}
648
649
650mode_t
651posix_acl_inherit_file (xlator_t *this, loc_t *loc, dict_t *params, mode_t mode,
652 int32_t umask)
653{
654 mode_t retmode = 0;
655
656 retmode = posix_acl_inherit (this, loc, params, mode, umask, 0);
657
658 return retmode;
659}
660
661
662int
663posix_acl_ctx_update (inode_t *inode, xlator_t *this, struct iatt *buf)
664{
665 struct posix_acl_ctx *ctx = NULL((void*)0);
666 int ret = 0;
667
668 ctx = posix_acl_ctx_get (inode, this);
669 if (!ctx) {
670 ret = -1;
671 goto out;
672 }
673
674 LOCK(&inode->lock)pthread_spin_lock (&inode->lock);
675 {
676 ctx->uid = buf->ia_uid;
677 ctx->gid = buf->ia_gid;
678 ctx->perm = st_mode_from_ia (buf->ia_prot, buf->ia_type);
679 }
680 UNLOCK(&inode->lock)pthread_spin_unlock (&inode->lock);
681out:
682 return ret;
683}
684
685
686int
687posix_acl_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
688 int op_ret, int op_errno, inode_t *inode,
689 struct iatt *buf, dict_t *xattr, struct iatt *postparent)
690{
691 struct posix_acl *acl_access = NULL((void*)0);
692 struct posix_acl *acl_default = NULL((void*)0);
693 struct posix_acl *old_access = NULL((void*)0);
694 struct posix_acl *old_default = NULL((void*)0);
695 data_t *data = NULL((void*)0);
696 int ret = 0;
697 dict_t *my_xattr = NULL((void*)0);
698
699 if (op_ret != 0)
700 goto unwind;
701
702 ret = posix_acl_get (inode, this, &old_access, &old_default);
703
704 data = dict_get (xattr, POSIX_ACL_ACCESS_XATTR"system.posix_acl_access");
705 if (!data)
706 goto acl_default;
707
708 if (old_access &&
709 posix_acl_matches_xattr (this, old_access, data->data,
710 data->len)) {
711 acl_access = posix_acl_ref (this, old_access);
712 } else {
713 acl_access = posix_acl_from_xattr (this, data->data,
714 data->len);
715 }
716
717acl_default:
718 data = dict_get (xattr, POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default");
719 if (!data)
720 goto acl_set;
721
722 if (old_default &&
723 posix_acl_matches_xattr (this, old_default, data->data,
724 data->len)) {
725 acl_default = posix_acl_ref (this, old_default);
726 } else {
727 acl_default = posix_acl_from_xattr (this, data->data,
728 data->len);
729 }
730
731acl_set:
732 posix_acl_ctx_update (inode, this, buf);
733
734 ret = posix_acl_set (inode, this, acl_access, acl_default);
735 if (ret)
736 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("failed to set ACL in context"); } while
(0); _gf_log (this->name, "posix-acl.c", __FUNCTION__, 737
, GF_LOG_WARNING, "failed to set ACL in context"); } while (0
)
737 "failed to set ACL in context")do { do { if (0) printf ("failed to set ACL in context"); } while
(0); _gf_log (this->name, "posix-acl.c", __FUNCTION__, 737
, GF_LOG_WARNING, "failed to set ACL in context"); } while (0
)
;
738unwind:
739 my_xattr = frame->local;
740 frame->local = NULL((void*)0);
741 STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xattr,do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 742, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_lookup_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, xattr, postparent); (*__glusterfs_this_location
()) = old_THIS; } while (0)
742 postparent)do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 742, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_lookup_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, xattr, postparent); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
743
744 if (acl_access)
745 posix_acl_unref (this, acl_access);
746 if (acl_default)
747 posix_acl_unref (this, acl_default);
748 if (old_access)
749 posix_acl_unref (this, old_access);
750 if (old_default)
751 posix_acl_unref (this, old_default);
752 if (my_xattr)
753 dict_unref (my_xattr);
754
755 return 0;
756}
757
758
759int
760posix_acl_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc,
761 dict_t *xattr)
762{
763 int ret = 0;
764 dict_t *my_xattr = NULL((void*)0);
765
766 if (!loc->parent)
767 /* lookup of / is always permitted */
768 goto green;
769
770 if (acl_permits (frame, loc->parent, POSIX_ACL_EXECUTE(0x01)))
771 goto green;
772 else
773 goto red;
774
775green:
776 if (xattr) {
777 my_xattr = dict_ref (xattr);
778 } else {
779 my_xattr = dict_new ();
780 }
781
782 ret = dict_set_int8 (my_xattr, POSIX_ACL_ACCESS_XATTR"system.posix_acl_access", 0);
783 if (ret)
784 gf_log (this->name, GF_LOG_WARNING, "failed to set key %s",do { do { if (0) printf ("failed to set key %s", "system.posix_acl_access"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 785, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_access"
); } while (0)
785 POSIX_ACL_ACCESS_XATTR)do { do { if (0) printf ("failed to set key %s", "system.posix_acl_access"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 785, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_access"
); } while (0)
;
786
787 ret = dict_set_int8 (my_xattr, POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default", 0);
788 if (ret)
789 gf_log (this->name, GF_LOG_WARNING, "failed to set key %s",do { do { if (0) printf ("failed to set key %s", "system.posix_acl_default"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 790, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_default"
); } while (0)
790 POSIX_ACL_DEFAULT_XATTR)do { do { if (0) printf ("failed to set key %s", "system.posix_acl_default"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 790, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_default"
); } while (0)
;
791
792 frame->local = my_xattr;
793 STACK_WIND (frame, posix_acl_lookup_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 795, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->lookup_cbk) tmp_cbk = posix_acl_lookup_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->lookup"
; _new->unwind_to = "posix_acl_lookup_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->lookup); (this->children->xlator
)->fops->lookup (_new, (this->children->xlator), loc
, my_xattr); (*__glusterfs_this_location()) = old_THIS; } while
(0)
794 FIRST_CHILD (this), FIRST_CHILD (this)->fops->lookup,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 795, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->lookup_cbk) tmp_cbk = posix_acl_lookup_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->lookup"
; _new->unwind_to = "posix_acl_lookup_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->lookup); (this->children->xlator
)->fops->lookup (_new, (this->children->xlator), loc
, my_xattr); (*__glusterfs_this_location()) = old_THIS; } while
(0)
795 loc, my_xattr)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 795, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->lookup_cbk) tmp_cbk = posix_acl_lookup_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->lookup"
; _new->unwind_to = "posix_acl_lookup_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->lookup); (this->children->xlator
)->fops->lookup (_new, (this->children->xlator), loc
, my_xattr); (*__glusterfs_this_location()) = old_THIS; } while
(0)
;
796 return 0;
797red:
798 STACK_UNWIND_STRICT (lookup, frame, -1, EACCES, NULL, NULL, NULL,do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 799, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_lookup_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0)
799 NULL)do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 799, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_lookup_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
800
801 return 0;
802}
803
804
805int
806posix_acl_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int mask,
807 dict_t *xdata)
808{
809 int op_ret = 0;
810 int op_errno = 0;
811 int perm = 0;
812 int mode = 0;
813 int is_fuse_call = 0;
814
815 is_fuse_call = __is_fuse_call (frame);
816
817 if (mask & R_OK4)
818 perm |= POSIX_ACL_READ(0x04);
819 if (mask & W_OK2)
820 perm |= POSIX_ACL_WRITE(0x02);
821 if (mask & X_OK1)
822 perm |= POSIX_ACL_EXECUTE(0x01);
823 if (!mask) {
824 goto unwind;
825 }
826 if (!perm) {
827 op_ret = -1;
828 op_errno = EINVAL22;
829 goto unwind;
830 }
831
832 if (is_fuse_call) {
833 mode = acl_permits (frame, loc->inode, perm);
834 if (mode) {
835 op_ret = 0;
836 op_errno = 0;
837 } else {
838 op_ret = -1;
839 op_errno = EACCES13;
840 }
841 } else {
842 if (perm & POSIX_ACL_READ(0x04)) {
843 if (acl_permits (frame, loc->inode, POSIX_ACL_READ(0x04)))
844 mode |= POSIX_ACL_READ(0x04);
845 }
846
847 if (perm & POSIX_ACL_WRITE(0x02)) {
848 if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE(0x02)))
849 mode |= POSIX_ACL_WRITE(0x02);
850 }
851
852 if (perm & POSIX_ACL_EXECUTE(0x01)) {
853 if (acl_permits (frame, loc->inode, POSIX_ACL_EXECUTE(0x01)))
854 mode |= POSIX_ACL_EXECUTE(0x01);
855 }
856 }
857
858unwind:
859 if (is_fuse_call)
860 STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, NULL)do { fop_access_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 860, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_access_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, ((void*)0)); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
861 else
862 STACK_UNWIND_STRICT (access, frame, 0, mode, NULL)do { fop_access_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 862, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_access_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, 0,
mode, ((void*)0)); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
863 return 0;
864}
865
866
867int
868posix_acl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
869 int op_ret, int op_errno, struct iatt *prebuf,
870 struct iatt *postbuf, dict_t *xdata)
871{
872 STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf,do { fop_truncate_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 873, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_truncate_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
873 postbuf, xdata)do { fop_truncate_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 873, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_truncate_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
874
875 return 0;
876}
877
878
879int
880posix_acl_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t off,
881 dict_t *xdata)
882{
883 if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE(0x02)))
884 goto green;
885 else
886 goto red;
887green:
888 STACK_WIND (frame, posix_acl_truncate_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 890, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->truncate_cbk) tmp_cbk = posix_acl_truncate_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->truncate"
; _new->unwind_to = "posix_acl_truncate_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->truncate); (this->children->xlator
)->fops->truncate (_new, (this->children->xlator)
, loc, off, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
889 FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 890, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->truncate_cbk) tmp_cbk = posix_acl_truncate_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->truncate"
; _new->unwind_to = "posix_acl_truncate_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->truncate); (this->children->xlator
)->fops->truncate (_new, (this->children->xlator)
, loc, off, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
890 loc, off, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 890, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->truncate_cbk) tmp_cbk = posix_acl_truncate_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->truncate"
; _new->unwind_to = "posix_acl_truncate_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->truncate); (this->children->xlator
)->fops->truncate (_new, (this->children->xlator)
, loc, off, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
891 return 0;
892red:
893 STACK_UNWIND_STRICT (truncate, frame, -1, EACCES, NULL, NULL, NULL)do { fop_truncate_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 893, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_truncate_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
894 return 0;
895}
896
897
898int
899posix_acl_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
900 int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
901{
902 STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata)do { fop_open_cbk_t fn = ((void*)0); call_frame_t *_parent = (
(void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do {
do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 902, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_open_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, fd, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
903
904 return 0;
905}
906
907
908int
909posix_acl_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
910 fd_t *fd, dict_t *xdata)
911{
912 int perm = 0;
913
914 switch (flags & O_ACCMODE0003) {
915 case O_RDONLY00:
916 perm = POSIX_ACL_READ(0x04);
917
918 /* If O_FMODE_EXEC is present, its good enough
919 to have '--x' perm, and its not covered in
920 O_ACCMODE bits */
921 if (flags & O_FMODE_EXEC040)
922 perm = POSIX_ACL_EXECUTE(0x01);
923
924 break;
925 case O_WRONLY01:
926 case O_APPEND02000:
927 case O_TRUNC01000:
928 perm = POSIX_ACL_WRITE(0x02);
929 break;
930 case O_RDWR02:
931 perm = POSIX_ACL_READ(0x04)|POSIX_ACL_WRITE(0x02);
932 break;
933 }
934
935 if (acl_permits (frame, loc->inode, perm))
936 goto green;
937 else
938 goto red;
939green:
940 STACK_WIND (frame, posix_acl_open_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 942, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->open_cbk) tmp_cbk = posix_acl_open_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->open"; _new
->unwind_to = "posix_acl_open_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->open); (this->children->xlator
)->fops->open (_new, (this->children->xlator), loc
, flags, fd, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
941 FIRST_CHILD(this), FIRST_CHILD(this)->fops->open,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 942, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->open_cbk) tmp_cbk = posix_acl_open_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->open"; _new
->unwind_to = "posix_acl_open_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->open); (this->children->xlator
)->fops->open (_new, (this->children->xlator), loc
, flags, fd, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
942 loc, flags, fd, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 942, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->open_cbk) tmp_cbk = posix_acl_open_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->open"; _new
->unwind_to = "posix_acl_open_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->open); (this->children->xlator
)->fops->open (_new, (this->children->xlator), loc
, flags, fd, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
943 return 0;
944red:
945 STACK_UNWIND_STRICT (open, frame, -1, EACCES, NULL, xdata)do { fop_open_cbk_t fn = ((void*)0); call_frame_t *_parent = (
(void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do {
do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 945, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_open_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
946 return 0;
947}
948
949
950int
951posix_acl_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
952 int op_ret, int op_errno, struct iovec *vector,
953 int count, struct iatt *stbuf, struct iobref *iobref,
954 dict_t *xdata)
955{
956 STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count,do { fop_readv_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 957, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readv_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, vector, count, stbuf, iobref, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
957 stbuf, iobref, xdata)do { fop_readv_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 957, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readv_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, vector, count, stbuf, iobref, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
958 return 0;
959}
960
961
962int
963posix_acl_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
964 size_t size, off_t offset, uint32_t flags, dict_t *xdata)
965{
966 if (__is_fuse_call (frame))
967 goto green;
968
969 if (acl_permits (frame, fd->inode, POSIX_ACL_READ(0x04)))
970 goto green;
971 else
972 goto red;
973
974green:
975 STACK_WIND (frame, posix_acl_readv_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 977, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readv_cbk) tmp_cbk = posix_acl_readv_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readv"; _new
->unwind_to = "posix_acl_readv_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readv); (this->children->xlator
)->fops->readv (_new, (this->children->xlator), fd
, size, offset, flags, xdata); (*__glusterfs_this_location())
= old_THIS; } while (0)
976 FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 977, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readv_cbk) tmp_cbk = posix_acl_readv_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readv"; _new
->unwind_to = "posix_acl_readv_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readv); (this->children->xlator
)->fops->readv (_new, (this->children->xlator), fd
, size, offset, flags, xdata); (*__glusterfs_this_location())
= old_THIS; } while (0)
977 fd, size, offset, flags, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 977, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readv_cbk) tmp_cbk = posix_acl_readv_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readv"; _new
->unwind_to = "posix_acl_readv_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readv); (this->children->xlator
)->fops->readv (_new, (this->children->xlator), fd
, size, offset, flags, xdata); (*__glusterfs_this_location())
= old_THIS; } while (0)
;
978 return 0;
979red:
980 STACK_UNWIND_STRICT (readv, frame, -1, EACCES, NULL, 0, NULL, NULL, xdata)do { fop_readv_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 980, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readv_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), 0, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
981 return 0;
982}
983
984
985int
986posix_acl_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
987 int op_ret, int op_errno,
988 struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
989{
990 STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno,do { fop_writev_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 991, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_writev_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
991 prebuf, postbuf, xdata)do { fop_writev_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 991, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_writev_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
992 return 0;
993}
994
995
996int
997posix_acl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
998 struct iovec *vector, int count, off_t offset,
999 uint32_t flags, struct iobref *iobref, dict_t *xdata)
1000{
1001 if (__is_fuse_call (frame))
1002 goto green;
1003
1004 if (acl_permits (frame, fd->inode, POSIX_ACL_WRITE(0x02)))
1005 goto green;
1006 else
1007 goto red;
1008
1009green:
1010 STACK_WIND (frame, posix_acl_writev_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1012, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->writev_cbk) tmp_cbk = posix_acl_writev_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->writev";
_new->unwind_to = "posix_acl_writev_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->writev); (this->children->xlator
)->fops->writev (_new, (this->children->xlator), fd
, vector, count, offset, flags, iobref, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1011 FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1012, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->writev_cbk) tmp_cbk = posix_acl_writev_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->writev";
_new->unwind_to = "posix_acl_writev_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->writev); (this->children->xlator
)->fops->writev (_new, (this->children->xlator), fd
, vector, count, offset, flags, iobref, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1012 fd, vector, count, offset, flags, iobref, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1012, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->writev_cbk) tmp_cbk = posix_acl_writev_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->writev";
_new->unwind_to = "posix_acl_writev_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->writev); (this->children->xlator
)->fops->writev (_new, (this->children->xlator), fd
, vector, count, offset, flags, iobref, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1013 return 0;
1014red:
1015 STACK_UNWIND_STRICT (writev, frame, -1, EACCES, NULL, NULL, xdata)do { fop_writev_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1015, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_writev_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1016 return 0;
1017}
1018
1019
1020
1021int
1022posix_acl_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1023 int op_ret, int op_errno, struct iatt *prebuf,
1024 struct iatt *postbuf, dict_t *xdata)
1025{
1026 STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno,do { fop_ftruncate_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1027, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_ftruncate_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1027 prebuf, postbuf, xdata)do { fop_ftruncate_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1027, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_ftruncate_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1028 return 0;
1029}
1030
1031
1032int
1033posix_acl_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd,
1034 off_t offset, dict_t *xdata)
1035{
1036 if (__is_fuse_call (frame))
1037 goto green;
1038
1039 if (acl_permits (frame, fd->inode, POSIX_ACL_WRITE(0x02)))
1040 goto green;
1041 else
1042 goto red;
1043
1044green:
1045 STACK_WIND (frame, posix_acl_ftruncate_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1047, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->ftruncate_cbk) tmp_cbk = posix_acl_ftruncate_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->ftruncate"
; _new->unwind_to = "posix_acl_ftruncate_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->ftruncate); (this->children->
xlator)->fops->ftruncate (_new, (this->children->
xlator), fd, offset, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
1046 FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1047, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->ftruncate_cbk) tmp_cbk = posix_acl_ftruncate_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->ftruncate"
; _new->unwind_to = "posix_acl_ftruncate_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->ftruncate); (this->children->
xlator)->fops->ftruncate (_new, (this->children->
xlator), fd, offset, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
1047 fd, offset, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1047, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->ftruncate_cbk) tmp_cbk = posix_acl_ftruncate_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->ftruncate"
; _new->unwind_to = "posix_acl_ftruncate_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->ftruncate); (this->children->
xlator)->fops->ftruncate (_new, (this->children->
xlator), fd, offset, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
;
1048 return 0;
1049red:
1050 STACK_UNWIND_STRICT (ftruncate, frame, -1, EACCES, NULL, NULL, xdata)do { fop_ftruncate_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1050, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_ftruncate_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1051 return 0;
1052}
1053
1054
1055int
1056posix_acl_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1057 int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
1058{
1059 STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata)do { fop_opendir_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1059, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_opendir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, fd, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1060
1061 return 0;
1062}
1063
1064
1065int
1066posix_acl_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata)
1067{
1068 if (acl_permits (frame, loc->inode, POSIX_ACL_READ(0x04)))
1069 goto green;
1070 else
1071 goto red;
1072green:
1073 STACK_WIND (frame, posix_acl_opendir_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1075, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->opendir_cbk) tmp_cbk = posix_acl_opendir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->opendir"
; _new->unwind_to = "posix_acl_opendir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->opendir); (this->children->xlator
)->fops->opendir (_new, (this->children->xlator),
loc, fd, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1074 FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1075, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->opendir_cbk) tmp_cbk = posix_acl_opendir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->opendir"
; _new->unwind_to = "posix_acl_opendir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->opendir); (this->children->xlator
)->fops->opendir (_new, (this->children->xlator),
loc, fd, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1075 loc, fd, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1075, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->opendir_cbk) tmp_cbk = posix_acl_opendir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->opendir"
; _new->unwind_to = "posix_acl_opendir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->opendir); (this->children->xlator
)->fops->opendir (_new, (this->children->xlator),
loc, fd, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
;
1076 return 0;
1077red:
1078 STACK_UNWIND_STRICT (opendir, frame, -1, EACCES, NULL, xdata)do { fop_opendir_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1078, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_opendir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1079 return 0;
1080}
1081
1082
1083int
1084posix_acl_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1085 int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
1086 struct iatt *preparent, struct iatt *postparent,
1087 dict_t *xdata)
1088{
1089 if (op_ret != 0)
1090 goto unwind;
1091
1092 posix_acl_ctx_update (inode, this, buf);
1093
1094unwind:
1095 STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf,do { fop_mkdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1096, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mkdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1096 preparent, postparent, xdata)do { fop_mkdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1096, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mkdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1097 return 0;
1098}
1099
1100
1101int
1102posix_acl_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
1103 mode_t umask, dict_t *xdata)
1104{
1105 mode_t newmode = 0;
1106
1107 newmode = mode;
Value stored to 'newmode' is never read
1108 if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE(0x02)|POSIX_ACL_EXECUTE(0x01)))
1109 goto green;
1110 else
1111 goto red;
1112green:
1113 newmode = posix_acl_inherit_dir (this, loc, xdata, mode, umask);
1114
1115 STACK_WIND (frame, posix_acl_mkdir_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1117, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->mkdir_cbk) tmp_cbk = posix_acl_mkdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->mkdir"; _new
->unwind_to = "posix_acl_mkdir_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->mkdir); (this->children->xlator
)->fops->mkdir (_new, (this->children->xlator), loc
, newmode, umask, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1116 FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1117, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->mkdir_cbk) tmp_cbk = posix_acl_mkdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->mkdir"; _new
->unwind_to = "posix_acl_mkdir_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->mkdir); (this->children->xlator
)->fops->mkdir (_new, (this->children->xlator), loc
, newmode, umask, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1117 loc, newmode, umask, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1117, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->mkdir_cbk) tmp_cbk = posix_acl_mkdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->mkdir"; _new
->unwind_to = "posix_acl_mkdir_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->mkdir); (this->children->xlator
)->fops->mkdir (_new, (this->children->xlator), loc
, newmode, umask, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1118 return 0;
1119red:
1120 STACK_UNWIND_STRICT (mkdir, frame, -1, EACCES, NULL, NULL, NULL, NULL,do { fop_mkdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1121, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mkdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0)); (*__glusterfs_this_location()) = old_THIS; } while (0)
1121 NULL)do { fop_mkdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1121, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mkdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0)); (*__glusterfs_this_location()) = old_THIS; } while (0)
;
1122 return 0;
1123}
1124
1125
1126int
1127posix_acl_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1128 int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
1129 struct iatt *preparent, struct iatt *postparent,
1130 dict_t *xdata)
1131{
1132 if (op_ret != 0)
1133 goto unwind;
1134
1135 posix_acl_ctx_update (inode, this, buf);
1136
1137unwind:
1138 STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf,do { fop_mknod_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1139, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mknod_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1139 preparent, postparent, xdata)do { fop_mknod_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1139, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mknod_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1140 return 0;
1141}
1142
1143
1144int
1145posix_acl_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
1146 dev_t rdev, mode_t umask, dict_t *xdata)
1147{
1148 mode_t newmode = 0;
1149
1150 newmode = mode;
1151 if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE(0x02)|POSIX_ACL_EXECUTE(0x01)))
1152 goto green;
1153 else
1154 goto red;
1155green:
1156 newmode = posix_acl_inherit_file (this, loc, xdata, mode, umask);
1157
1158 STACK_WIND (frame, posix_acl_mknod_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1160, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->mknod_cbk) tmp_cbk = posix_acl_mknod_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->mknod"; _new
->unwind_to = "posix_acl_mknod_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->mknod); (this->children->xlator
)->fops->mknod (_new, (this->children->xlator), loc
, newmode, rdev, umask, xdata); (*__glusterfs_this_location()
) = old_THIS; } while (0)
1159 FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1160, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->mknod_cbk) tmp_cbk = posix_acl_mknod_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->mknod"; _new
->unwind_to = "posix_acl_mknod_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->mknod); (this->children->xlator
)->fops->mknod (_new, (this->children->xlator), loc
, newmode, rdev, umask, xdata); (*__glusterfs_this_location()
) = old_THIS; } while (0)
1160 loc, newmode, rdev, umask, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1160, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->mknod_cbk) tmp_cbk = posix_acl_mknod_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->mknod"; _new
->unwind_to = "posix_acl_mknod_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->mknod); (this->children->xlator
)->fops->mknod (_new, (this->children->xlator), loc
, newmode, rdev, umask, xdata); (*__glusterfs_this_location()
) = old_THIS; } while (0)
;
1161 return 0;
1162red:
1163 STACK_UNWIND_STRICT (mknod, frame, -1, EACCES, NULL, NULL, NULL, NULL,do { fop_mknod_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1164, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mknod_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0)); (*__glusterfs_this_location()) = old_THIS; } while (0)
1164 NULL)do { fop_mknod_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1164, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_mknod_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0)); (*__glusterfs_this_location()) = old_THIS; } while (0)
;
1165 return 0;
1166}
1167
1168
1169int
1170posix_acl_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1171 int op_ret, int op_errno, fd_t *fd, inode_t *inode,
1172 struct iatt *buf, struct iatt *preparent,
1173 struct iatt *postparent, dict_t *xdata)
1174{
1175 if (op_ret != 0)
1176 goto unwind;
1177
1178 posix_acl_ctx_update (inode, this, buf);
1179
1180unwind:
1181 STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf,do { fop_create_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1182, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_create_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, fd, inode, buf, preparent, postparent, xdata); (*
__glusterfs_this_location()) = old_THIS; } while (0)
1182 preparent, postparent, xdata)do { fop_create_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1182, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_create_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, fd, inode, buf, preparent, postparent, xdata); (*
__glusterfs_this_location()) = old_THIS; } while (0)
;
1183 return 0;
1184}
1185
1186
1187int
1188posix_acl_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
1189 mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
1190{
1191 mode_t newmode = 0;
1192
1193 newmode = mode;
1194 if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE(0x02)|POSIX_ACL_EXECUTE(0x01)))
1195 goto green;
1196 else
1197 goto red;
1198green:
1199 newmode = posix_acl_inherit_file (this, loc, xdata, mode, umask);
1200
1201 STACK_WIND (frame, posix_acl_create_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1203, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->create_cbk) tmp_cbk = posix_acl_create_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->create";
_new->unwind_to = "posix_acl_create_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->create); (this->children->xlator
)->fops->create (_new, (this->children->xlator), loc
, flags, newmode, umask, fd, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1202 FIRST_CHILD(this), FIRST_CHILD(this)->fops->create,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1203, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->create_cbk) tmp_cbk = posix_acl_create_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->create";
_new->unwind_to = "posix_acl_create_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->create); (this->children->xlator
)->fops->create (_new, (this->children->xlator), loc
, flags, newmode, umask, fd, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1203 loc, flags, newmode, umask, fd, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1203, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->create_cbk) tmp_cbk = posix_acl_create_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->create";
_new->unwind_to = "posix_acl_create_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->create); (this->children->xlator
)->fops->create (_new, (this->children->xlator), loc
, flags, newmode, umask, fd, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1204 return 0;
1205red:
1206 STACK_UNWIND_STRICT (create, frame, -1, EACCES, NULL, NULL, NULL,do { fop_create_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1207, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_create_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0), ((void*)0)); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1207 NULL, NULL, NULL)do { fop_create_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1207, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_create_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0), ((void*)0)); (*__glusterfs_this_location()) = old_THIS; }
while (0)
;
1208 return 0;
1209}
1210
1211
1212int
1213posix_acl_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1214 int op_ret, int op_errno, inode_t *inode,
1215 struct iatt *buf, struct iatt *preparent,
1216 struct iatt *postparent, dict_t *xdata)
1217{
1218 if (op_ret != 0)
1219 goto unwind;
1220
1221 posix_acl_ctx_update (inode, this, buf);
1222
1223unwind:
1224 STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf,do { fop_symlink_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1225, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_symlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1225 preparent, postparent, xdata)do { fop_symlink_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1225, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_symlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1226 return 0;
1227}
1228
1229
1230int
1231posix_acl_symlink (call_frame_t *frame, xlator_t *this, const char *linkname,
1232 loc_t *loc, mode_t umask, dict_t *xdata)
1233{
1234 if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE(0x02)|POSIX_ACL_EXECUTE(0x01)))
1235 goto green;
1236 else
1237 goto red;
1238green:
1239 STACK_WIND (frame, posix_acl_symlink_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1241, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->symlink_cbk) tmp_cbk = posix_acl_symlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->symlink"
; _new->unwind_to = "posix_acl_symlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->symlink); (this->children->xlator
)->fops->symlink (_new, (this->children->xlator),
linkname, loc, umask, xdata); (*__glusterfs_this_location())
= old_THIS; } while (0)
1240 FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1241, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->symlink_cbk) tmp_cbk = posix_acl_symlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->symlink"
; _new->unwind_to = "posix_acl_symlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->symlink); (this->children->xlator
)->fops->symlink (_new, (this->children->xlator),
linkname, loc, umask, xdata); (*__glusterfs_this_location())
= old_THIS; } while (0)
1241 linkname, loc, umask, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1241, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->symlink_cbk) tmp_cbk = posix_acl_symlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->symlink"
; _new->unwind_to = "posix_acl_symlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->symlink); (this->children->xlator
)->fops->symlink (_new, (this->children->xlator),
linkname, loc, umask, xdata); (*__glusterfs_this_location())
= old_THIS; } while (0)
;
1242 return 0;
1243red:
1244 STACK_UNWIND_STRICT (symlink, frame, -1, EACCES, NULL, NULL, NULL,do { fop_symlink_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1245, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_symlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), xdata);
(*__glusterfs_this_location()) = old_THIS; } while (0)
1245 NULL, xdata)do { fop_symlink_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1245, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_symlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), xdata);
(*__glusterfs_this_location()) = old_THIS; } while (0)
;
1246 return 0;
1247}
1248
1249
1250int
1251posix_acl_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1252 int op_ret, int op_errno, struct iatt *preparent,
1253 struct iatt *postparent, dict_t *xdata)
1254{
1255 if (op_ret != 0)
1256 goto unwind;
1257unwind:
1258 STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno,do { fop_unlink_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1259, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_unlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1259 preparent, postparent, xdata)do { fop_unlink_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1259, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_unlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1260 return 0;
1261}
1262
1263
1264int
1265posix_acl_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
1266 dict_t *xdata)
1267{
1268 if (!sticky_permits (frame, loc->parent, loc->inode))
1269 goto red;
1270
1271 if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE(0x02)|POSIX_ACL_EXECUTE(0x01)))
1272 goto green;
1273 else
1274 goto red;
1275green:
1276 STACK_WIND (frame, posix_acl_unlink_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1278, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->unlink_cbk) tmp_cbk = posix_acl_unlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->unlink";
_new->unwind_to = "posix_acl_unlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->unlink); (this->children->xlator
)->fops->unlink (_new, (this->children->xlator), loc
, xflag, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1277 FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1278, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->unlink_cbk) tmp_cbk = posix_acl_unlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->unlink";
_new->unwind_to = "posix_acl_unlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->unlink); (this->children->xlator
)->fops->unlink (_new, (this->children->xlator), loc
, xflag, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1278 loc, xflag, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1278, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->unlink_cbk) tmp_cbk = posix_acl_unlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->unlink";
_new->unwind_to = "posix_acl_unlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->unlink); (this->children->xlator
)->fops->unlink (_new, (this->children->xlator), loc
, xflag, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
;
1279 return 0;
1280red:
1281 STACK_UNWIND_STRICT (unlink, frame, -1, EACCES, NULL, NULL, xdata)do { fop_unlink_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1281, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_unlink_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1282 return 0;
1283}
1284
1285
1286int
1287posix_acl_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1288 int op_ret, int op_errno,
1289 struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
1290{
1291 if (op_ret != 0)
1292 goto unwind;
1293unwind:
1294 STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno,do { fop_rmdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1295, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rmdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1295 preparent, postparent, xdata)do { fop_rmdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1295, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rmdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1296 return 0;
1297}
1298
1299
1300int
1301posix_acl_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata)
1302{
1303 if (!sticky_permits (frame, loc->parent, loc->inode))
1304 goto red;
1305
1306 if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE(0x02)|POSIX_ACL_EXECUTE(0x01)))
1307 goto green;
1308 else
1309 goto red;
1310green:
1311 STACK_WIND (frame, posix_acl_rmdir_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1313, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->rmdir_cbk) tmp_cbk = posix_acl_rmdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->rmdir"; _new
->unwind_to = "posix_acl_rmdir_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->rmdir); (this->children->xlator
)->fops->rmdir (_new, (this->children->xlator), loc
, flags, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1312 FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1313, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->rmdir_cbk) tmp_cbk = posix_acl_rmdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->rmdir"; _new
->unwind_to = "posix_acl_rmdir_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->rmdir); (this->children->xlator
)->fops->rmdir (_new, (this->children->xlator), loc
, flags, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1313 loc, flags, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1313, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->rmdir_cbk) tmp_cbk = posix_acl_rmdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->rmdir"; _new
->unwind_to = "posix_acl_rmdir_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->rmdir); (this->children->xlator
)->fops->rmdir (_new, (this->children->xlator), loc
, flags, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
;
1314 return 0;
1315red:
1316 STACK_UNWIND_STRICT (rmdir, frame, -1, EACCES, NULL, NULL, xdata)do { fop_rmdir_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1316, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rmdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1317 return 0;
1318}
1319
1320
1321int
1322posix_acl_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1323 int op_ret, int op_errno, struct iatt *buf,
1324 struct iatt *preoldparent, struct iatt *postoldparent,
1325 struct iatt *prenewparent, struct iatt *postnewparent,
1326 dict_t *xdata)
1327{
1328 if (op_ret != 0)
1329 goto unwind;
1330unwind:
1331 STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf,do { fop_rename_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1333, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rename_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, buf, preoldparent, postoldparent, prenewparent, postnewparent
, xdata); (*__glusterfs_this_location()) = old_THIS; } while (
0)
1332 preoldparent, postoldparent,do { fop_rename_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1333, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rename_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, buf, preoldparent, postoldparent, prenewparent, postnewparent
, xdata); (*__glusterfs_this_location()) = old_THIS; } while (
0)
1333 prenewparent, postnewparent, xdata)do { fop_rename_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1333, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rename_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, buf, preoldparent, postoldparent, prenewparent, postnewparent
, xdata); (*__glusterfs_this_location()) = old_THIS; } while (
0)
;
1334 return 0;
1335}
1336
1337
1338int
1339posix_acl_rename (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, dict_t *xdata)
1340{
1341 if (!acl_permits (frame, old->parent, POSIX_ACL_WRITE(0x02)))
1342 goto red;
1343
1344 if (!acl_permits (frame, new->parent, POSIX_ACL_WRITE(0x02)))
1345 goto red;
1346
1347 if (!sticky_permits (frame, old->parent, old->inode))
1348 goto red;
1349
1350 if (new->inode) {
1351 if (!sticky_permits (frame, new->parent, new->inode))
1352 goto red;
1353 }
1354
1355 STACK_WIND (frame, posix_acl_rename_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1357, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->rename_cbk) tmp_cbk = posix_acl_rename_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->rename";
_new->unwind_to = "posix_acl_rename_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->rename); (this->children->xlator
)->fops->rename (_new, (this->children->xlator), old
, new, xdata); (*__glusterfs_this_location()) = old_THIS; } while
(0)
1356 FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1357, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->rename_cbk) tmp_cbk = posix_acl_rename_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->rename";
_new->unwind_to = "posix_acl_rename_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->rename); (this->children->xlator
)->fops->rename (_new, (this->children->xlator), old
, new, xdata); (*__glusterfs_this_location()) = old_THIS; } while
(0)
1357 old, new, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1357, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->rename_cbk) tmp_cbk = posix_acl_rename_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->rename";
_new->unwind_to = "posix_acl_rename_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->rename); (this->children->xlator
)->fops->rename (_new, (this->children->xlator), old
, new, xdata); (*__glusterfs_this_location()) = old_THIS; } while
(0)
;
1358 return 0;
1359red:
1360 STACK_UNWIND_STRICT (rename, frame, -1, EACCES, NULL, NULL, NULL, NULL,do { fop_rename_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1361, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rename_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0), ((void*)0)); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1361 NULL, NULL)do { fop_rename_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1361, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_rename_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), ((void*)0), ((void*)0), ((void*
)0), ((void*)0)); (*__glusterfs_this_location()) = old_THIS; }
while (0)
;
1362 return 0;
1363}
1364
1365
1366int
1367posix_acl_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1368 int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
1369 struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
1370{
1371 if (op_ret != 0)
1372 goto unwind;
1373unwind:
1374 STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf,do { fop_link_cbk_t fn = ((void*)0); call_frame_t *_parent = (
(void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do {
do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1375, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_link_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1375 preparent, postparent, xdata)do { fop_link_cbk_t fn = ((void*)0); call_frame_t *_parent = (
(void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do {
do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1375, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_link_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, inode, buf, preparent, postparent, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1376 return 0;
1377}
1378
1379
1380int
1381posix_acl_link (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, dict_t *xdata)
1382{
1383 struct posix_acl_ctx *ctx = NULL((void*)0);
1384 int op_errno = 0;
1385
1386 ctx = posix_acl_ctx_get (old->inode, this);
1387 if (!ctx) {
1388 op_errno = EIO5;
1389 goto red;
1390 }
1391
1392 if (!acl_permits (frame, new->parent, POSIX_ACL_WRITE(0x02))) {
1393 op_errno = EACCES13;
1394 goto red;
1395 }
1396
1397 STACK_WIND (frame, posix_acl_link_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1399, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->link_cbk) tmp_cbk = posix_acl_link_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->link"; _new
->unwind_to = "posix_acl_link_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->link); (this->children->xlator
)->fops->link (_new, (this->children->xlator), old
, new, xdata); (*__glusterfs_this_location()) = old_THIS; } while
(0)
1398 FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1399, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->link_cbk) tmp_cbk = posix_acl_link_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->link"; _new
->unwind_to = "posix_acl_link_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->link); (this->children->xlator
)->fops->link (_new, (this->children->xlator), old
, new, xdata); (*__glusterfs_this_location()) = old_THIS; } while
(0)
1399 old, new, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1399, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->link_cbk) tmp_cbk = posix_acl_link_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->link"; _new
->unwind_to = "posix_acl_link_cbk"; pthread_spin_init (&
_new->lock, 0); pthread_spin_lock (&frame->root->
stack_lock); { _new->next = frame->root->frames.next
; _new->prev = &frame->root->frames; if (frame->
root->frames.next) frame->root->frames.next->prev
= _new; frame->root->frames.next = _new; frame->ref_count
++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->link); (this->children->xlator
)->fops->link (_new, (this->children->xlator), old
, new, xdata); (*__glusterfs_this_location()) = old_THIS; } while
(0)
;
1400 return 0;
1401red:
1402 STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, NULL, NULL, xdata)do { fop_link_cbk_t fn = ((void*)0); call_frame_t *_parent = (
(void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do {
do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1402, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_link_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, op_errno, ((void*)0), ((void*)0), ((void*)0), ((void*)0), xdata
); (*__glusterfs_this_location()) = old_THIS; } while (0)
;
1403
1404 return 0;
1405}
1406
1407
1408int
1409posix_acl_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1410 int op_ret, int op_errno, gf_dirent_t *entries,
1411 dict_t *xdata)
1412{
1413 if (op_ret != 0)
1414 goto unwind;
1415unwind:
1416 STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata)do { fop_readdir_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1416, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, entries, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
;
1417 return 0;
1418}
1419
1420
1421int
1422posix_acl_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
1423 off_t offset, dict_t *xdata)
1424{
1425 if (acl_permits (frame, fd->inode, POSIX_ACL_READ(0x04)))
1426 goto green;
1427 else
1428 goto red;
1429green:
1430 STACK_WIND (frame, posix_acl_readdir_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1432, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdir_cbk) tmp_cbk = posix_acl_readdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdir"
; _new->unwind_to = "posix_acl_readdir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdir); (this->children->xlator
)->fops->readdir (_new, (this->children->xlator),
fd, size, offset, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1431 FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1432, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdir_cbk) tmp_cbk = posix_acl_readdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdir"
; _new->unwind_to = "posix_acl_readdir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdir); (this->children->xlator
)->fops->readdir (_new, (this->children->xlator),
fd, size, offset, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1432 fd, size, offset, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1432, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdir_cbk) tmp_cbk = posix_acl_readdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdir"
; _new->unwind_to = "posix_acl_readdir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdir); (this->children->xlator
)->fops->readdir (_new, (this->children->xlator),
fd, size, offset, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1433 return 0;
1434red:
1435 STACK_UNWIND_STRICT (readdir, frame, -1, EACCES, NULL, xdata)do { fop_readdir_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1435, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readdir_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1436
1437 return 0;
1438}
1439
1440
1441int
1442posix_acl_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1443 int op_ret, int op_errno, gf_dirent_t *entries,
1444 dict_t *xdata)
1445{
1446 gf_dirent_t *entry = NULL((void*)0);
1447 struct posix_acl *acl_access = NULL((void*)0);
1448 struct posix_acl *acl_default = NULL((void*)0);
1449 data_t *data = NULL((void*)0);
1450 int ret = 0;
1451
1452 if (op_ret <= 0)
1453 goto unwind;
1454
1455 list_for_each_entry (entry, &entries->list, list)for (entry = ((typeof(*entry) *)((char *)((&entries->list
)->next)-(unsigned long)(&((typeof(*entry) *)0)->list
))); &entry->list != (&entries->list); entry = (
(typeof(*entry) *)((char *)(entry->list.next)-(unsigned long
)(&((typeof(*entry) *)0)->list))))
{
1456 /* Update the inode ctx */
1457 if (!entry->dict || !entry->inode)
1458 continue;
1459
1460 ret = posix_acl_get (entry->inode, this,
1461 &acl_access, &acl_default);
1462
1463 data = dict_get (entry->dict, POSIX_ACL_ACCESS_XATTR"system.posix_acl_access");
1464 if (!data)
1465 goto acl_default;
1466
1467 if (acl_access &&
1468 posix_acl_matches_xattr (this, acl_access, data->data,
1469 data->len))
1470 goto acl_default;
1471
1472 if (acl_access)
1473 posix_acl_unref(this, acl_access);
1474
1475 acl_access = posix_acl_from_xattr (this, data->data,
1476 data->len);
1477
1478 acl_default:
1479 data = dict_get (entry->dict, POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default");
1480 if (!data)
1481 goto acl_set;
1482
1483 if (acl_default &&
1484 posix_acl_matches_xattr (this, acl_default, data->data,
1485 data->len))
1486 goto acl_set;
1487
1488 if (acl_default)
1489 posix_acl_unref(this, acl_default);
1490
1491 acl_default = posix_acl_from_xattr (this, data->data,
1492 data->len);
1493
1494 acl_set:
1495 posix_acl_ctx_update (entry->inode, this, &entry->d_stat);
1496
1497 ret = posix_acl_set (entry->inode, this,
1498 acl_access, acl_default);
1499 if (ret)
1500 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("failed to set ACL in context"); } while
(0); _gf_log (this->name, "posix-acl.c", __FUNCTION__, 1501
, GF_LOG_WARNING, "failed to set ACL in context"); } while (0
)
1501 "failed to set ACL in context")do { do { if (0) printf ("failed to set ACL in context"); } while
(0); _gf_log (this->name, "posix-acl.c", __FUNCTION__, 1501
, GF_LOG_WARNING, "failed to set ACL in context"); } while (0
)
;
1502
1503 if (acl_access)
1504 posix_acl_unref(this, acl_access);
1505 if (acl_default)
1506 posix_acl_unref(this, acl_default);
1507 }
1508
1509unwind:
1510 STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata)do { fop_readdirp_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1510, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readdirp_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, entries, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
;
1511 return 0;
1512}
1513
1514
1515int
1516posix_acl_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
1517 off_t offset, dict_t *dict)
1518{
1519 int ret = 0;
1520 dict_t *alloc_dict = NULL((void*)0);
1521
1522 if (acl_permits (frame, fd->inode, POSIX_ACL_READ(0x04)))
1523 goto green;
1524 else
1525 goto red;
1526green:
1527 if (!dict)
1528 dict = alloc_dict = dict_new ();
1529
1530 if (dict) {
1531 ret = dict_set_int8 (dict, POSIX_ACL_ACCESS_XATTR"system.posix_acl_access", 0);
1532 if (ret)
1533 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("failed to set key %s", "system.posix_acl_access"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 1535, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_access"
); } while (0)
1534 "failed to set key %s",do { do { if (0) printf ("failed to set key %s", "system.posix_acl_access"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 1535, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_access"
); } while (0)
1535 POSIX_ACL_ACCESS_XATTR)do { do { if (0) printf ("failed to set key %s", "system.posix_acl_access"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 1535, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_access"
); } while (0)
;
1536
1537 ret = dict_set_int8 (dict, POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default", 0);
1538 if (ret)
1539 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("failed to set key %s", "system.posix_acl_default"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 1541, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_default"
); } while (0)
1540 "failed to set key %s",do { do { if (0) printf ("failed to set key %s", "system.posix_acl_default"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 1541, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_default"
); } while (0)
1541 POSIX_ACL_DEFAULT_XATTR)do { do { if (0) printf ("failed to set key %s", "system.posix_acl_default"
); } while (0); _gf_log (this->name, "posix-acl.c", __FUNCTION__
, 1541, GF_LOG_WARNING, "failed to set key %s", "system.posix_acl_default"
); } while (0)
;
1542 }
1543
1544 STACK_WIND (frame, posix_acl_readdirp_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1546, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdirp_cbk) tmp_cbk = posix_acl_readdirp_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdirp"
; _new->unwind_to = "posix_acl_readdirp_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdirp); (this->children->xlator
)->fops->readdirp (_new, (this->children->xlator)
, fd, size, offset, dict); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1545 FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1546, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdirp_cbk) tmp_cbk = posix_acl_readdirp_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdirp"
; _new->unwind_to = "posix_acl_readdirp_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdirp); (this->children->xlator
)->fops->readdirp (_new, (this->children->xlator)
, fd, size, offset, dict); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1546 fd, size, offset, dict)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1546, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdirp_cbk) tmp_cbk = posix_acl_readdirp_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdirp"
; _new->unwind_to = "posix_acl_readdirp_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdirp); (this->children->xlator
)->fops->readdirp (_new, (this->children->xlator)
, fd, size, offset, dict); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1547
1548 if (alloc_dict)
1549 dict_unref (alloc_dict);
1550 return 0;
1551red:
1552 STACK_UNWIND_STRICT (readdirp, frame, -1, EACCES, NULL, NULL)do { fop_readdirp_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1552, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_readdirp_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0)); (*__glusterfs_this_location())
= old_THIS; } while (0)
;
1553
1554 return 0;
1555}
1556
1557
1558int
1559setattr_scrutiny (call_frame_t *frame, inode_t *inode, struct iatt *buf,
1560 int valid)
1561{
1562 struct posix_acl_ctx *ctx = NULL((void*)0);
1563
1564 if (frame_is_super_user (frame))
1565 return 0;
1566
1567 ctx = posix_acl_ctx_get (inode, frame->this);
1568 if (!ctx)
1569 return EIO5;
1570
1571 if (valid & GF_SET_ATTR_MODE0x1) {
1572/*
1573 The effective UID of the calling process must match the owner of the
1574 file, or the process must be privileged
1575*/
1576 if (!frame_is_user (frame, ctx->uid))
1577 return EPERM1;
1578/*
1579 If the calling process is not privileged (Linux: does not have the
1580 CAP_FSETID capability), and the group of the file does not match the
1581 effective group ID of the process or one of its supplementary group
1582 IDs, the S_ISGID bit will be turned off, but this will not cause an
1583 error to be returned.
1584
1585*/
1586 if (!frame_in_group (frame, ctx->gid))
1587 buf->ia_prot.sgid = 0;
1588 }
1589
1590 if (valid & (GF_SET_ATTR_ATIME0x10 | GF_SET_ATTR_MTIME0x20)) {
1591/*
1592 Changing timestamps is permitted when: either the process has appropri?
1593 ate privileges, or the effective user ID equals the user ID of the
1594 file, or times is NULL and the process has write permission for the
1595 file.
1596*/
1597 if (!frame_is_user (frame, ctx->uid) &&
1598 !acl_permits (frame, inode, POSIX_ACL_WRITE(0x02)))
1599 return EACCES13;
1600 }
1601
1602 if (valid & GF_SET_ATTR_UID0x2) {
1603 if ((!frame_is_super_user (frame)) &&
1604 (buf->ia_uid != ctx->uid))
1605 return EPERM1;
1606 }
1607
1608 if (valid & GF_SET_ATTR_GID0x4) {
1609 if (!frame_is_user (frame, ctx->uid))
1610 return EPERM1;
1611 if (!frame_in_group (frame, buf->ia_gid))
1612 return EPERM1;
1613 }
1614
1615 return 0;
1616}
1617
1618
1619int
1620posix_acl_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1621 int op_ret, int op_errno,
1622 struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
1623{
1624 inode_t *inode = NULL((void*)0);
1625
1626 inode = frame->local;
1627 frame->local = NULL((void*)0);
1628
1629 if (op_ret != 0)
1630 goto unwind;
1631
1632 posix_acl_ctx_update (inode, this, postbuf);
1633
1634unwind:
1635 STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, prebuf,do { fop_setattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1636, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_setattr_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1636 postbuf, xdata)do { fop_setattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1636, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_setattr_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1637 return 0;
1638}
1639
1640
1641int
1642posix_acl_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
1643 struct iatt *buf, int valid, dict_t *xdata)
1644{
1645 int op_errno = 0;
1646
1647 op_errno = setattr_scrutiny (frame, loc->inode, buf, valid);
1648
1649 if (op_errno)
1650 goto red;
1651
1652 frame->local = loc->inode;
1653
1654 STACK_WIND (frame, posix_acl_setattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1656, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->setattr_cbk) tmp_cbk = posix_acl_setattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->setattr"
; _new->unwind_to = "posix_acl_setattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->setattr); (this->children->xlator
)->fops->setattr (_new, (this->children->xlator),
loc, buf, valid, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1655 FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1656, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->setattr_cbk) tmp_cbk = posix_acl_setattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->setattr"
; _new->unwind_to = "posix_acl_setattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->setattr); (this->children->xlator
)->fops->setattr (_new, (this->children->xlator),
loc, buf, valid, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1656 loc, buf, valid, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1656, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->setattr_cbk) tmp_cbk = posix_acl_setattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->setattr"
; _new->unwind_to = "posix_acl_setattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->setattr); (this->children->xlator
)->fops->setattr (_new, (this->children->xlator),
loc, buf, valid, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1657 return 0;
1658red:
1659 STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, xdata)do { fop_setattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1659, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_setattr_cbk_t )frame->ret
; _parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, op_errno, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1660
1661 return 0;
1662}
1663
1664
1665int
1666posix_acl_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1667 int op_ret, int op_errno,
1668 struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
1669{
1670 inode_t *inode = NULL((void*)0);
1671
1672 inode = frame->local;
1673 frame->local = NULL((void*)0);
1674
1675 if (op_ret != 0)
1676 goto unwind;
1677
1678 posix_acl_ctx_update (inode, this, postbuf);
1679
1680unwind:
1681 STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, prebuf,do { fop_fsetattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1682, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fsetattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1682 postbuf, xdata)do { fop_fsetattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1682, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fsetattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, prebuf, postbuf, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1683 return 0;
1684}
1685
1686
1687int
1688posix_acl_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
1689 struct iatt *buf, int valid, dict_t *xdata)
1690{
1691 int op_errno = 0;
1692
1693 op_errno = setattr_scrutiny (frame, fd->inode, buf, valid);
1694
1695 if (op_errno)
1696 goto red;
1697
1698 frame->local = fd->inode;
1699
1700 STACK_WIND (frame, posix_acl_fsetattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1702, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fsetattr_cbk) tmp_cbk = posix_acl_fsetattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fsetattr"
; _new->unwind_to = "posix_acl_fsetattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fsetattr); (this->children->xlator
)->fops->fsetattr (_new, (this->children->xlator)
, fd, buf, valid, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1701 FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1702, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fsetattr_cbk) tmp_cbk = posix_acl_fsetattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fsetattr"
; _new->unwind_to = "posix_acl_fsetattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fsetattr); (this->children->xlator
)->fops->fsetattr (_new, (this->children->xlator)
, fd, buf, valid, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1702 fd, buf, valid, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1702, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fsetattr_cbk) tmp_cbk = posix_acl_fsetattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fsetattr"
; _new->unwind_to = "posix_acl_fsetattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fsetattr); (this->children->xlator
)->fops->fsetattr (_new, (this->children->xlator)
, fd, buf, valid, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1703 return 0;
1704red:
1705 STACK_UNWIND_STRICT (fsetattr, frame, -1, EACCES, NULL, NULL, xdata)do { fop_fsetattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1705, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fsetattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1706
1707 return 0;
1708}
1709
1710
1711int
1712setxattr_scrutiny (call_frame_t *frame, inode_t *inode, dict_t *xattr)
1713{
1714 struct posix_acl_ctx *ctx = NULL((void*)0);
1715 int found = 0;
1716
1717 if (frame_is_super_user (frame))
1718 return 0;
1719
1720 ctx = posix_acl_ctx_get (inode, frame->this);
1721 if (!ctx)
1722 return EIO5;
1723
1724 if (dict_get (xattr, POSIX_ACL_ACCESS_XATTR"system.posix_acl_access")) {
1725 found = 1;
1726 if (!frame_is_user (frame, ctx->uid))
1727 return EPERM1;
1728 }
1729
1730 if (dict_get (xattr, POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default")) {
1731 found = 1;
1732 if (!frame_is_user (frame, ctx->uid))
1733 return EPERM1;
1734 }
1735
1736 if (!found && !acl_permits (frame, inode, POSIX_ACL_WRITE(0x02)))
1737 return EACCES13;
1738
1739 return 0;
1740}
1741
1742
1743struct posix_acl *
1744posix_acl_xattr_update (xlator_t *this, inode_t *inode, dict_t *xattr,
1745 char *name, struct posix_acl *old)
1746{
1747 struct posix_acl *acl = NULL((void*)0);
1748 data_t *data = NULL((void*)0);
1749
1750 data = dict_get (xattr, name);
1751 if (data) {
1752 acl = posix_acl_from_xattr (this, data->data,
1753 data->len);
1754 }
1755
1756 if (!acl && old)
1757 acl = posix_acl_ref (this, old);
1758
1759 return acl;
1760}
1761
1762
1763int
1764posix_acl_setxattr_update (xlator_t *this, inode_t *inode, dict_t *xattr)
1765{
1766 struct posix_acl *acl_access = NULL((void*)0);
1767 struct posix_acl *acl_default = NULL((void*)0);
1768 struct posix_acl *old_access = NULL((void*)0);
1769 struct posix_acl *old_default = NULL((void*)0);
1770 struct posix_acl_ctx *ctx = NULL((void*)0);
1771 int ret = 0;
1772
1773 ctx = posix_acl_ctx_get (inode, this);
1774 if (!ctx)
1775 return -1;
1776
1777 ret = posix_acl_get (inode, this, &old_access, &old_default);
1778
1779 acl_access = posix_acl_xattr_update (this, inode, xattr,
1780 POSIX_ACL_ACCESS_XATTR"system.posix_acl_access",
1781 old_access);
1782
1783 acl_default = posix_acl_xattr_update (this, inode, xattr,
1784 POSIX_ACL_DEFAULT_XATTR"system.posix_acl_default",
1785 old_default);
1786
1787 ret = posix_acl_set (inode, this, acl_access, acl_default);
1788
1789 if (acl_access && acl_access != old_access) {
1790 posix_acl_access_set_mode (acl_access, ctx);
1791 }
1792
1793 if (acl_access)
1794 posix_acl_unref (this, acl_access);
1795 if (acl_default)
1796 posix_acl_unref (this, acl_default);
1797 if (old_access)
1798 posix_acl_unref (this, old_access);
1799 if (old_default)
1800 posix_acl_unref (this, old_default);
1801
1802 return ret;
1803}
1804
1805
1806int
1807posix_acl_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1808 int op_ret, int op_errno, dict_t *xdata)
1809{
1810 STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata)do { fop_setxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1810, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_setxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1811
1812 return 0;
1813}
1814
1815
1816int
1817posix_acl_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
1818 dict_t *xattr, int flags, dict_t *xdata)
1819{
1820 int op_errno = 0;
1821
1822 op_errno = setxattr_scrutiny (frame, loc->inode, xattr);
1823
1824 if (op_errno != 0)
1825 goto red;
1826
1827 posix_acl_setxattr_update (this, loc->inode, xattr);
1828
1829 STACK_WIND (frame, posix_acl_setxattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1831, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->setxattr_cbk) tmp_cbk = posix_acl_setxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->setxattr"
; _new->unwind_to = "posix_acl_setxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->setxattr); (this->children->xlator
)->fops->setxattr (_new, (this->children->xlator)
, loc, xattr, flags, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
1830 FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1831, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->setxattr_cbk) tmp_cbk = posix_acl_setxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->setxattr"
; _new->unwind_to = "posix_acl_setxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->setxattr); (this->children->xlator
)->fops->setxattr (_new, (this->children->xlator)
, loc, xattr, flags, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
1831 loc, xattr, flags, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1831, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->setxattr_cbk) tmp_cbk = posix_acl_setxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->setxattr"
; _new->unwind_to = "posix_acl_setxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->setxattr); (this->children->xlator
)->fops->setxattr (_new, (this->children->xlator)
, loc, xattr, flags, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
;
1832 return 0;
1833red:
1834 STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata)do { fop_setxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1834, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_setxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, op_errno, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1835
1836 return 0;
1837}
1838
1839
1840int
1841posix_acl_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1842 int op_ret, int op_errno, dict_t *xdata)
1843{
1844 STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata)do { fop_fsetxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1844, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fsetxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1845
1846 return 0;
1847}
1848
1849
1850int
1851posix_acl_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
1852 dict_t *xattr, int flags, dict_t *xdata)
1853{
1854 int op_errno = 0;
1855
1856 op_errno = setxattr_scrutiny (frame, fd->inode, xattr);
1857
1858 if (op_errno != 0)
1859 goto red;
1860
1861 posix_acl_setxattr_update (this, fd->inode, xattr);
1862
1863 STACK_WIND (frame, posix_acl_fsetxattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1865, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fsetxattr_cbk) tmp_cbk = posix_acl_fsetxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fsetxattr"
; _new->unwind_to = "posix_acl_fsetxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fsetxattr); (this->children->
xlator)->fops->fsetxattr (_new, (this->children->
xlator), fd, xattr, flags, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1864 FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1865, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fsetxattr_cbk) tmp_cbk = posix_acl_fsetxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fsetxattr"
; _new->unwind_to = "posix_acl_fsetxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fsetxattr); (this->children->
xlator)->fops->fsetxattr (_new, (this->children->
xlator), fd, xattr, flags, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1865 fd, xattr, flags, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1865, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fsetxattr_cbk) tmp_cbk = posix_acl_fsetxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fsetxattr"
; _new->unwind_to = "posix_acl_fsetxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fsetxattr); (this->children->
xlator)->fops->fsetxattr (_new, (this->children->
xlator), fd, xattr, flags, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0)
;
1866 return 0;
1867red:
1868 STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, xdata)do { fop_fsetxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1868, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fsetxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, op_errno, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1869
1870 return 0;
1871}
1872
1873
1874int
1875posix_acl_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1876 int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
1877{
1878 STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, xattr, xdata)do { fop_getxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1878, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_getxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, xattr, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1879
1880 return 0;
1881}
1882
1883
1884int
1885posix_acl_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
1886 const char *name, dict_t *xdata)
1887{
1888 if (whitelisted_xattr (name))
1889 goto green;
1890
1891 if (acl_permits (frame, loc->inode, POSIX_ACL_READ(0x04)))
1892 goto green;
1893 else
1894 goto red;
1895green:
1896 STACK_WIND (frame, posix_acl_getxattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1898, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->getxattr_cbk) tmp_cbk = posix_acl_getxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->getxattr"
; _new->unwind_to = "posix_acl_getxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->getxattr); (this->children->xlator
)->fops->getxattr (_new, (this->children->xlator)
, loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1897 FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1898, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->getxattr_cbk) tmp_cbk = posix_acl_getxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->getxattr"
; _new->unwind_to = "posix_acl_getxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->getxattr); (this->children->xlator
)->fops->getxattr (_new, (this->children->xlator)
, loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1898 loc, name, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1898, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->getxattr_cbk) tmp_cbk = posix_acl_getxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->getxattr"
; _new->unwind_to = "posix_acl_getxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->getxattr); (this->children->xlator
)->fops->getxattr (_new, (this->children->xlator)
, loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1899 return 0;
1900red:
1901 STACK_UNWIND_STRICT (getxattr, frame, -1, EACCES, NULL, xdata)do { fop_getxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1901, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_getxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1902
1903 return 0;
1904}
1905
1906
1907int
1908posix_acl_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1909 int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
1910{
1911 STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, xattr, xdata)do { fop_fgetxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1911, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fgetxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, xattr, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1912
1913 return 0;
1914}
1915
1916
1917int
1918posix_acl_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
1919 const char *name, dict_t *xdata)
1920{
1921 if (whitelisted_xattr (name))
1922 goto green;
1923
1924 if (acl_permits (frame, fd->inode, POSIX_ACL_READ(0x04)))
1925 goto green;
1926 else
1927 goto red;
1928green:
1929 STACK_WIND (frame, posix_acl_fgetxattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1931, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fgetxattr_cbk) tmp_cbk = posix_acl_fgetxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fgetxattr"
; _new->unwind_to = "posix_acl_fgetxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fgetxattr); (this->children->
xlator)->fops->fgetxattr (_new, (this->children->
xlator), fd, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1930 FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1931, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fgetxattr_cbk) tmp_cbk = posix_acl_fgetxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fgetxattr"
; _new->unwind_to = "posix_acl_fgetxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fgetxattr); (this->children->
xlator)->fops->fgetxattr (_new, (this->children->
xlator), fd, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1931 fd, name, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1931, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fgetxattr_cbk) tmp_cbk = posix_acl_fgetxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fgetxattr"
; _new->unwind_to = "posix_acl_fgetxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fgetxattr); (this->children->
xlator)->fops->fgetxattr (_new, (this->children->
xlator), fd, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1932 return 0;
1933red:
1934 STACK_UNWIND_STRICT (fgetxattr, frame, -1, EACCES, NULL, xdata)do { fop_fgetxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1934, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_fgetxattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 13, ((void*)0), xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1935
1936 return 0;
1937}
1938
1939
1940int
1941posix_acl_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
1942 int op_ret, int op_errno, dict_t *xdata)
1943{
1944 STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata)do { fop_removexattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1944, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_removexattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1945
1946 return 0;
1947}
1948
1949
1950int
1951posix_acl_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
1952 const char *name, dict_t *xdata)
1953{
1954 struct posix_acl_ctx *ctx = NULL((void*)0);
1955 int op_errno = EACCES13;
1956
1957 if (frame_is_super_user (frame))
1958 goto green;
1959
1960 ctx = posix_acl_ctx_get (loc->inode, this);
1961 if (!ctx) {
1962 op_errno = EIO5;
1963 goto red;
1964 }
1965
1966 if (whitelisted_xattr (name)) {
1967 if (!frame_is_user (frame, ctx->uid)) {
1968 op_errno = EPERM1;
1969 goto red;
1970 }
1971 }
1972
1973 if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE(0x02)))
1974 goto green;
1975 else
1976 goto red;
1977green:
1978 STACK_WIND (frame, posix_acl_removexattr_cbk,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1980, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->removexattr_cbk) tmp_cbk = posix_acl_removexattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->removexattr"
; _new->unwind_to = "posix_acl_removexattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->removexattr); (this->children->
xlator)->fops->removexattr (_new, (this->children->
xlator), loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1979 FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1980, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->removexattr_cbk) tmp_cbk = posix_acl_removexattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->removexattr"
; _new->unwind_to = "posix_acl_removexattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->removexattr); (this->children->
xlator)->fops->removexattr (_new, (this->children->
xlator), loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
1980 loc, name, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "posix-acl.c", __FUNCTION__, 1980, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->removexattr_cbk) tmp_cbk = posix_acl_removexattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->removexattr"
; _new->unwind_to = "posix_acl_removexattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->removexattr); (this->children->
xlator)->fops->removexattr (_new, (this->children->
xlator), loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1981 return 0;
1982red:
1983 STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, xdata)do { fop_removexattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "posix-acl.c", __FUNCTION__, 1983, GF_LOG_CRITICAL, "!frame"
); } while (0); break; } fn = (fop_removexattr_cbk_t )frame->
ret; _parent = frame->parent; pthread_spin_lock (&frame
->root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, op_errno, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
;
1984
1985 return 0;
1986}
1987
1988
1989int
1990posix_acl_forget (xlator_t *this, inode_t *inode)
1991{
1992 struct posix_acl_ctx *ctx = NULL((void*)0);
1993
1994 ctx = posix_acl_ctx_get (inode, this);
1995 if (!ctx)
1996 goto out;
1997
1998 if (ctx->acl_access)
1999 posix_acl_unref (this, ctx->acl_access);
2000
2001 if (ctx->acl_default)
2002 posix_acl_unref (this, ctx->acl_default);
2003
2004 FREE (ctx)if (ctx != ((void*)0)) { free ((void *)ctx); ctx = (void *)0xeeeeeeee
; }
;
2005out:
2006 return 0;
2007}
2008
2009
2010int
2011reconfigure (xlator_t *this, dict_t *options)
2012{
2013 struct posix_acl_conf *conf = NULL((void*)0);
2014
2015 conf = this->private;
2016
2017 GF_OPTION_RECONF ("super-uid", conf->super_uid, options, uint32, err)do { int val_ret = 0; val_ret = xlator_option_reconf_uint32 (
(*__glusterfs_this_location()), options, "super-uid", &(conf
->super_uid)); if (val_ret) goto err; } while (0)
;
2018
2019 return 0;
2020err:
2021 return -1;
2022}
2023
2024
2025int
2026init (xlator_t *this)
2027{
2028 struct posix_acl_conf *conf = NULL((void*)0);
2029 struct posix_acl *minacl = NULL((void*)0);
2030 struct posix_ace *minace = NULL((void*)0);
2031
2032 conf = CALLOC (1, sizeof (*conf))__gf_default_calloc(1,sizeof (*conf));
2033 if (!conf) {
2034 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("out of memory"); } while (0); _gf_log
(this->name, "posix-acl.c", __FUNCTION__, 2035, GF_LOG_ERROR
, "out of memory"); } while (0)
2035 "out of memory")do { do { if (0) printf ("out of memory"); } while (0); _gf_log
(this->name, "posix-acl.c", __FUNCTION__, 2035, GF_LOG_ERROR
, "out of memory"); } while (0)
;
2036 return -1;
2037 }
2038
2039 LOCK_INIT (&conf->acl_lock)pthread_spin_init (&conf->acl_lock, 0);
2040
2041 this->private = conf;
2042
2043 minacl = posix_acl_new (this, 3);
2044 if (!minacl)
2045 return -1;
2046
2047 minace = minacl->entries;
2048 minace[0].tag = POSIX_ACL_USER_OBJ(0x01);
2049 minace[1].tag = POSIX_ACL_GROUP_OBJ(0x04);
2050 minace[2].tag = POSIX_ACL_OTHER(0x20);
2051
2052 conf->minimal_acl = minacl;
2053
2054 GF_OPTION_INIT ("super-uid", conf->super_uid, uint32, err)do { int val_ret = 0; val_ret = xlator_option_init_uint32 ((*
__glusterfs_this_location()), (*__glusterfs_this_location())->
options, "super-uid", &(conf->super_uid)); if (val_ret
) goto err; } while (0)
;
2055
2056 return 0;
2057err:
2058 return -1;
2059}
2060
2061
2062int
2063fini (xlator_t *this)
2064{
2065 struct posix_acl_conf *conf = NULL((void*)0);
2066 struct posix_acl *minacl = NULL((void*)0);
2067
2068 conf = this->private;
2069 if (!conf)
2070 return 0;
2071 this->private = NULL((void*)0);
2072
2073 minacl = conf->minimal_acl;
2074
2075 LOCK (&conf->acl_lock)pthread_spin_lock (&conf->acl_lock);
2076 {
2077 conf->minimal_acl = NULL((void*)0);
2078 }
2079 UNLOCK (&conf->acl_lock)pthread_spin_unlock (&conf->acl_lock);
2080
2081 LOCK_DESTROY (&conf->acl_lock)pthread_spin_destroy (&conf->acl_lock);
2082
2083 GF_FREE (minacl)__gf_free (minacl);
2084
2085 GF_FREE (conf)__gf_free (conf);
2086
2087 return 0;
2088}
2089
2090
2091struct xlator_fops fops = {
2092 .lookup = posix_acl_lookup,
2093 .open = posix_acl_open,
2094#if FD_MODE_CHECK_IS_IMPLEMENTED
2095 .readv = posix_acl_readv,
2096 .writev = posix_acl_writev,
2097 .ftruncate = posix_acl_ftruncate,
2098 .fsetattr = posix_acl_fsetattr,
2099 .fsetxattr = posix_acl_fsetxattr,
2100 .fgetxattr = posix_acl_fgetxattr,
2101#endif
2102 .access = posix_acl_access,
2103 .truncate = posix_acl_truncate,
2104 .mkdir = posix_acl_mkdir,
2105 .mknod = posix_acl_mknod,
2106 .create = posix_acl_create,
2107 .symlink = posix_acl_symlink,
2108 .unlink = posix_acl_unlink,
2109 .rmdir = posix_acl_rmdir,
2110 .rename = posix_acl_rename,
2111 .link = posix_acl_link,
2112 .opendir = posix_acl_opendir,
2113 .readdir = posix_acl_readdir,
2114 .readdirp = posix_acl_readdirp,
2115 .setattr = posix_acl_setattr,
2116 .setxattr = posix_acl_setxattr,
2117 .getxattr = posix_acl_getxattr,
2118 .removexattr = posix_acl_removexattr,
2119};
2120
2121
2122struct xlator_cbks cbks = {
2123 .forget = posix_acl_forget
2124};
2125
2126
2127struct volume_options options[] = {
2128 { .key = {"super-uid"},
2129 .type = GF_OPTION_TYPE_INT,
2130 .default_value = "0",
2131 .description = "UID to be treated as super user's id instead of 0",
2132 },
2133 { .key = {NULL((void*)0)} },
2134};