| /linux-4.4.14/fs/hfsplus/ |
| H A D | posix_acl.c | 11 #include "acl.h"
15 struct posix_acl *acl; hfsplus_get_posix_acl() local
43 acl = posix_acl_from_xattr(&init_user_ns, value, size); hfsplus_get_posix_acl()
45 acl = NULL; hfsplus_get_posix_acl()
47 acl = ERR_PTR(size); hfsplus_get_posix_acl()
51 if (!IS_ERR(acl)) hfsplus_get_posix_acl()
52 set_cached_acl(inode, type, acl); hfsplus_get_posix_acl()
54 return acl; hfsplus_get_posix_acl()
57 int hfsplus_set_posix_acl(struct inode *inode, struct posix_acl *acl, hfsplus_set_posix_acl() argument
70 if (acl) { hfsplus_set_posix_acl()
71 err = posix_acl_equiv_mode(acl, &inode->i_mode); hfsplus_set_posix_acl()
81 return acl ? -EACCES : 0; hfsplus_set_posix_acl()
88 if (acl) { hfsplus_set_posix_acl()
89 size = posix_acl_xattr_size(acl->a_count); hfsplus_set_posix_acl()
95 err = posix_acl_to_xattr(&init_user_ns, acl, value, size); hfsplus_set_posix_acl()
106 set_cached_acl(inode, type, acl); hfsplus_set_posix_acl()
114 struct posix_acl *default_acl, *acl; hfsplus_init_posix_acl() local
123 err = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); hfsplus_init_posix_acl()
133 if (acl) { hfsplus_init_posix_acl()
135 err = hfsplus_set_posix_acl(inode, acl, hfsplus_init_posix_acl()
137 posix_acl_release(acl); hfsplus_init_posix_acl()
|
| H A D | acl.h | 2 * linux/fs/hfsplus/acl.h
15 int hfsplus_set_posix_acl(struct inode *inode, struct posix_acl *acl,
|
| H A D | xattr_security.c | 14 #include "acl.h"
|
| H A D | dir.c | 20 #include "acl.h"
|
| H A D | inode.c | 22 #include "acl.h"
|
| H A D | xattr.c | 13 #include "acl.h"
|
| /linux-4.4.14/fs/9p/ |
| H A D | acl.c | 23 #include "acl.h"
32 struct posix_acl *acl = NULL; __v9fs_get_acl() local
41 acl = posix_acl_from_xattr(&init_user_ns, value, size); __v9fs_get_acl()
42 if (IS_ERR(acl)) __v9fs_get_acl()
47 acl = NULL; __v9fs_get_acl()
49 acl = ERR_PTR(-EIO); __v9fs_get_acl()
53 return acl; __v9fs_get_acl()
69 /* get the default/access acl values and cache them */ v9fs_get_acl()
90 struct posix_acl *acl; v9fs_get_cached_acl() local
92 * 9p Always cache the acl value when v9fs_get_cached_acl()
95 acl = get_cached_acl(inode, type); v9fs_get_cached_acl()
96 BUG_ON(acl == ACL_NOT_CACHED); v9fs_get_cached_acl()
97 return acl; v9fs_get_cached_acl()
108 * On access = client and acl = on mode get the acl v9fs_iop_get_acl()
117 static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl) v9fs_set_acl() argument
123 if (!acl) v9fs_set_acl()
127 size = posix_acl_xattr_size(acl->a_count); v9fs_set_acl()
131 retval = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); v9fs_set_acl()
153 struct posix_acl *acl; v9fs_acl_chmod() local
157 acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS); v9fs_acl_chmod()
158 if (acl) { v9fs_acl_chmod()
159 retval = __posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); v9fs_acl_chmod()
162 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); v9fs_acl_chmod()
163 retval = v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl); v9fs_acl_chmod()
164 posix_acl_release(acl); v9fs_acl_chmod()
170 struct posix_acl *dacl, struct posix_acl *acl) v9fs_set_create_acl()
173 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); v9fs_set_create_acl()
175 v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl); v9fs_set_create_acl()
180 struct posix_acl *acl) v9fs_put_acl()
183 posix_acl_release(acl); v9fs_put_acl()
191 struct posix_acl *acl = NULL; v9fs_acl_mode() local
194 acl = v9fs_get_cached_acl(dir, ACL_TYPE_DEFAULT); v9fs_acl_mode()
195 if (IS_ERR(acl)) v9fs_acl_mode()
196 return PTR_ERR(acl); v9fs_acl_mode()
197 if (!acl) v9fs_acl_mode()
200 if (acl) { v9fs_acl_mode()
202 *dpacl = posix_acl_dup(acl); v9fs_acl_mode()
203 retval = __posix_acl_create(&acl, GFP_NOFS, &mode); v9fs_acl_mode()
207 *pacl = acl; v9fs_acl_mode()
209 posix_acl_release(acl); v9fs_acl_mode()
220 struct posix_acl *acl; v9fs_xattr_get_acl() local
228 * We allow set/get/list of acl when access=client is not specified v9fs_xattr_get_acl()
233 acl = v9fs_get_cached_acl(d_inode(dentry), handler->flags); v9fs_xattr_get_acl()
234 if (IS_ERR(acl)) v9fs_xattr_get_acl()
235 return PTR_ERR(acl); v9fs_xattr_get_acl()
236 if (acl == NULL) v9fs_xattr_get_acl()
238 error = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); v9fs_xattr_get_acl()
239 posix_acl_release(acl); v9fs_xattr_get_acl()
249 struct posix_acl *acl; v9fs_xattr_set_acl() local
270 /* update the cached acl value */ v9fs_xattr_set_acl()
271 acl = posix_acl_from_xattr(&init_user_ns, value, size); v9fs_xattr_set_acl()
272 if (IS_ERR(acl)) v9fs_xattr_set_acl()
273 return PTR_ERR(acl); v9fs_xattr_set_acl()
274 else if (acl) { v9fs_xattr_set_acl()
275 retval = posix_acl_valid(acl); v9fs_xattr_set_acl()
280 acl = NULL; v9fs_xattr_set_acl()
284 if (acl) { v9fs_xattr_set_acl()
286 retval = posix_acl_equiv_mode(acl, &mode); v9fs_xattr_set_acl()
297 acl = NULL; v9fs_xattr_set_acl()
315 retval = acl ? -EINVAL : 0; v9fs_xattr_set_acl()
324 set_cached_acl(inode, handler->flags, acl); v9fs_xattr_set_acl()
326 posix_acl_release(acl); v9fs_xattr_set_acl()
169 v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid, struct posix_acl *dacl, struct posix_acl *acl) v9fs_set_create_acl() argument
179 v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl) v9fs_put_acl() argument
|
| H A D | Makefile | 16 9p-$(CONFIG_9P_FS_POSIX_ACL) += acl.o
|
| H A D | acl.h | 25 extern void v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl);
39 struct posix_acl *acl) v9fs_set_create_acl()
44 struct posix_acl *acl) v9fs_put_acl()
36 v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid, struct posix_acl *dacl, struct posix_acl *acl) v9fs_set_create_acl() argument
43 v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl) v9fs_put_acl() argument
|
| H A D | vfs_inode_dotl.c | 48 #include "acl.h"
297 p9_debug(P9_DEBUG_VFS, "Failed to get acl values in creat %d\n", v9fs_vfs_atomic_open_dotl()
417 p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mkdir %d\n", v9fs_vfs_mkdir_dotl()
453 * so that we can set the acl with dentry v9fs_vfs_mkdir_dotl()
847 p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mknod %d\n", v9fs_vfs_mknod_dotl()
|
| H A D | vfs_super.c | 50 #include "acl.h"
|
| H A D | vfs_inode.c | 50 #include "acl.h"
|
| /linux-4.4.14/fs/ext4/ |
| H A D | acl.c | 2 * linux/fs/ext4/acl.c
10 #include "acl.h"
20 struct posix_acl *acl; ext4_acl_from_disk() local
35 acl = posix_acl_alloc(count, GFP_NOFS); ext4_acl_from_disk()
36 if (!acl) ext4_acl_from_disk()
43 acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); ext4_acl_from_disk()
44 acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); ext4_acl_from_disk()
46 switch (acl->a_entries[n].e_tag) { ext4_acl_from_disk()
59 acl->a_entries[n].e_uid = ext4_acl_from_disk()
67 acl->a_entries[n].e_gid = ext4_acl_from_disk()
78 return acl; ext4_acl_from_disk()
81 posix_acl_release(acl); ext4_acl_from_disk()
89 ext4_acl_to_disk(const struct posix_acl *acl, size_t *size) ext4_acl_to_disk() argument
95 *size = ext4_acl_size(acl->a_count); ext4_acl_to_disk()
96 ext_acl = kmalloc(sizeof(ext4_acl_header) + acl->a_count * ext4_acl_to_disk()
102 for (n = 0; n < acl->a_count; n++) { ext4_acl_to_disk()
103 const struct posix_acl_entry *acl_e = &acl->a_entries[n]; ext4_acl_to_disk()
147 struct posix_acl *acl; ext4_get_acl() local
168 acl = ext4_acl_from_disk(value, retval); ext4_get_acl()
170 acl = NULL; ext4_get_acl()
172 acl = ERR_PTR(retval); ext4_get_acl()
175 if (!IS_ERR(acl)) ext4_get_acl()
176 set_cached_acl(inode, type, acl); ext4_get_acl()
178 return acl; ext4_get_acl()
188 struct posix_acl *acl) __ext4_set_acl()
198 if (acl) { __ext4_set_acl()
199 error = posix_acl_equiv_mode(acl, &inode->i_mode); __ext4_set_acl()
206 acl = NULL; __ext4_set_acl()
214 return acl ? -EACCES : 0; __ext4_set_acl()
220 if (acl) { __ext4_set_acl()
221 value = ext4_acl_to_disk(acl, &size); __ext4_set_acl()
231 set_cached_acl(inode, type, acl); __ext4_set_acl()
237 ext4_set_acl(struct inode *inode, struct posix_acl *acl, int type) ext4_set_acl() argument
248 error = __ext4_set_acl(handle, inode, type, acl); ext4_set_acl()
264 struct posix_acl *default_acl, *acl; ext4_init_acl() local
267 error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); ext4_init_acl()
276 if (acl) { ext4_init_acl()
279 acl); ext4_init_acl()
280 posix_acl_release(acl); ext4_init_acl()
187 __ext4_set_acl(handle_t *handle, struct inode *inode, int type, struct posix_acl *acl) __ext4_set_acl() argument
|
| H A D | acl.h | 2 File: fs/ext4/acl.h
56 /* acl.c */
58 int ext4_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | Makefile | 13 ext4-$(CONFIG_EXT4_FS_POSIX_ACL) += acl.o
|
| H A D | page-io.c | 29 #include "acl.h"
|
| H A D | file.c | 32 #include "acl.h"
|
| H A D | xattr.c | 61 #include "acl.h"
|
| H A D | ialloc.c | 29 #include "acl.h"
|
| H A D | super.c | 50 #include "acl.h"
1187 {Opt_acl, "acl"},
|
| H A D | namei.c | 40 #include "acl.h"
|
| H A D | inode.c | 43 #include "acl.h"
|
| /linux-4.4.14/fs/ext2/ |
| H A D | acl.c | 2 * linux/fs/ext2/acl.c
13 #include "acl.h"
23 struct posix_acl *acl; ext2_acl_from_disk() local
38 acl = posix_acl_alloc(count, GFP_KERNEL); ext2_acl_from_disk()
39 if (!acl) ext2_acl_from_disk()
46 acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); ext2_acl_from_disk()
47 acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); ext2_acl_from_disk()
48 switch(acl->a_entries[n].e_tag) { ext2_acl_from_disk()
61 acl->a_entries[n].e_uid = ext2_acl_from_disk()
69 acl->a_entries[n].e_gid = ext2_acl_from_disk()
80 return acl; ext2_acl_from_disk()
83 posix_acl_release(acl); ext2_acl_from_disk()
91 ext2_acl_to_disk(const struct posix_acl *acl, size_t *size) ext2_acl_to_disk() argument
97 *size = ext2_acl_size(acl->a_count); ext2_acl_to_disk()
98 ext_acl = kmalloc(sizeof(ext2_acl_header) + acl->a_count * ext2_acl_to_disk()
104 for (n=0; n < acl->a_count; n++) { ext2_acl_to_disk()
105 const struct posix_acl_entry *acl_e = &acl->a_entries[n]; ext2_acl_to_disk()
147 struct posix_acl *acl; ext2_get_acl() local
168 acl = ext2_acl_from_disk(value, retval); ext2_get_acl()
170 acl = NULL; ext2_get_acl()
172 acl = ERR_PTR(retval); ext2_get_acl()
175 if (!IS_ERR(acl)) ext2_get_acl()
176 set_cached_acl(inode, type, acl); ext2_get_acl()
178 return acl; ext2_get_acl()
185 ext2_set_acl(struct inode *inode, struct posix_acl *acl, int type) ext2_set_acl() argument
195 if (acl) { ext2_set_acl()
196 error = posix_acl_equiv_mode(acl, &inode->i_mode); ext2_set_acl()
203 acl = NULL; ext2_set_acl()
211 return acl ? -EACCES : 0; ext2_set_acl()
217 if (acl) { ext2_set_acl()
218 value = ext2_acl_to_disk(acl, &size); ext2_set_acl()
227 set_cached_acl(inode, type, acl); ext2_set_acl()
240 struct posix_acl *default_acl, *acl; ext2_init_acl() local
243 error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); ext2_init_acl()
251 if (acl) { ext2_init_acl()
253 error = ext2_set_acl(inode, acl, ACL_TYPE_ACCESS); ext2_init_acl()
254 posix_acl_release(acl); ext2_init_acl()
|
| H A D | Makefile | 11 ext2-$(CONFIG_EXT2_FS_POSIX_ACL) += acl.o
|
| H A D | acl.h | 2 File: fs/ext2/acl.h
56 /* acl.c */
58 extern int ext2_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | file.c | 27 #include "acl.h"
|
| H A D | namei.c | 37 #include "acl.h"
|
| H A D | super.c | 37 #include "acl.h"
281 seq_puts(seq, ",acl"); ext2_show_options()
436 {Opt_acl, "acl"},
563 "(no)acl options not supported"); parse_options()
|
| H A D | ialloc.c | 22 #include "acl.h"
|
| H A D | xattr.c | 65 #include "acl.h"
|
| H A D | inode.c | 37 #include "acl.h"
|
| /linux-4.4.14/fs/ocfs2/ |
| H A D | acl.c | 4 * acl.c
9 * Lots of code in this file is copy from linux/fs/ext3/acl.c.
38 #include "acl.h"
41 * Convert from xattr value to acl struct.
46 struct posix_acl *acl; ocfs2_acl_from_xattr() local
55 acl = posix_acl_alloc(count, GFP_NOFS); ocfs2_acl_from_xattr()
56 if (!acl) ocfs2_acl_from_xattr()
62 acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); ocfs2_acl_from_xattr()
63 acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); ocfs2_acl_from_xattr()
64 switch(acl->a_entries[n].e_tag) { ocfs2_acl_from_xattr()
66 acl->a_entries[n].e_uid = ocfs2_acl_from_xattr()
71 acl->a_entries[n].e_gid = ocfs2_acl_from_xattr()
81 return acl; ocfs2_acl_from_xattr()
85 * Convert acl struct to xattr value.
87 static void *ocfs2_acl_to_xattr(const struct posix_acl *acl, size_t *size) ocfs2_acl_to_xattr() argument
93 *size = acl->a_count * sizeof(struct posix_acl_entry); ocfs2_acl_to_xattr()
100 for (n = 0; n < acl->a_count; n++, entry++) { ocfs2_acl_to_xattr()
101 entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag); ocfs2_acl_to_xattr()
102 entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm); ocfs2_acl_to_xattr()
103 switch(acl->a_entries[n].e_tag) { ocfs2_acl_to_xattr()
107 acl->a_entries[n].e_uid)); ocfs2_acl_to_xattr()
112 acl->a_entries[n].e_gid)); ocfs2_acl_to_xattr()
128 struct posix_acl *acl; ocfs2_get_acl_nolock() local
152 acl = ocfs2_acl_from_xattr(value, retval); ocfs2_get_acl_nolock()
154 acl = NULL; ocfs2_get_acl_nolock()
156 acl = ERR_PTR(retval); ocfs2_get_acl_nolock()
160 return acl; ocfs2_get_acl_nolock()
228 struct posix_acl *acl, ocfs2_set_acl()
243 if (acl) { ocfs2_set_acl()
245 ret = posix_acl_equiv_mode(acl, &mode); ocfs2_set_acl()
250 acl = NULL; ocfs2_set_acl()
261 return acl ? -EACCES : 0; ocfs2_set_acl()
267 if (acl) { ocfs2_set_acl()
268 value = ocfs2_acl_to_xattr(acl, &size); ocfs2_set_acl()
285 int ocfs2_iop_set_acl(struct inode *inode, struct posix_acl *acl, int type) ocfs2_iop_set_acl() argument
296 status = ocfs2_set_acl(NULL, inode, bh, type, acl, NULL, NULL); ocfs2_iop_set_acl()
306 struct posix_acl *acl; ocfs2_iop_get_acl() local
319 acl = ocfs2_get_acl_nolock(inode, type, di_bh); ocfs2_iop_get_acl()
323 return acl; ocfs2_iop_get_acl()
329 struct posix_acl *acl; ocfs2_acl_chmod() local
338 acl = ocfs2_get_acl_nolock(inode, ACL_TYPE_ACCESS, bh); ocfs2_acl_chmod()
339 if (IS_ERR(acl) || !acl) ocfs2_acl_chmod()
340 return PTR_ERR(acl); ocfs2_acl_chmod()
341 ret = __posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); ocfs2_acl_chmod()
345 acl, NULL, NULL); ocfs2_acl_chmod()
346 posix_acl_release(acl); ocfs2_acl_chmod()
363 struct posix_acl *acl = NULL; ocfs2_init_acl() local
369 acl = ocfs2_get_acl_nolock(dir, ACL_TYPE_DEFAULT, ocfs2_init_acl()
371 if (IS_ERR(acl)) ocfs2_init_acl()
372 return PTR_ERR(acl); ocfs2_init_acl()
374 if (!acl) { ocfs2_init_acl()
383 if ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) && acl) { ocfs2_init_acl()
386 ACL_TYPE_DEFAULT, acl, ocfs2_init_acl()
392 ret = __posix_acl_create(&acl, GFP_NOFS, &mode); ocfs2_init_acl()
405 acl, meta_ac, data_ac); ocfs2_init_acl()
409 posix_acl_release(acl); ocfs2_init_acl()
224 ocfs2_set_acl(handle_t *handle, struct inode *inode, struct buffer_head *di_bh, int type, struct posix_acl *acl, struct ocfs2_alloc_context *meta_ac, struct ocfs2_alloc_context *data_ac) ocfs2_set_acl() argument
|
| H A D | acl.h | 4 * acl.h
30 int ocfs2_iop_set_acl(struct inode *inode, struct posix_acl *acl, int type);
35 struct posix_acl *acl,
|
| H A D | Makefile | 44 acl.o
|
| H A D | namei.c | 64 #include "acl.h"
337 /* calculate meta data/clusters for setting security and acl xattr */ ocfs2_mknod()
|
| H A D | super.c | 219 {Opt_acl, "acl"},
1587 seq_printf(s, ",acl"); ocfs2_show_options()
|
| H A D | xattr.c | 58 #include "acl.h"
661 * The max space of acl xattr taken inline is ocfs2_calc_xattr_init()
3424 * for init security/acl xattrs of the new inode.
7192 * Initialize security and acl for a already created inode.
|
| H A D | file.c | 61 #include "acl.h"
|
| /linux-4.4.14/fs/jfs/ |
| H A D | acl.c | 32 struct posix_acl *acl; jfs_get_acl() local
37 acl = get_cached_acl(inode, type); jfs_get_acl()
38 if (acl != ACL_NOT_CACHED) jfs_get_acl()
39 return acl; jfs_get_acl()
63 acl = NULL; jfs_get_acl()
65 acl = ERR_PTR(size); jfs_get_acl()
67 acl = posix_acl_from_xattr(&init_user_ns, value, size); jfs_get_acl()
70 if (!IS_ERR(acl)) jfs_get_acl()
71 set_cached_acl(inode, type, acl); jfs_get_acl()
72 return acl; jfs_get_acl()
76 struct posix_acl *acl) __jfs_set_acl()
86 if (acl) { __jfs_set_acl()
87 rc = posix_acl_equiv_mode(acl, &inode->i_mode); __jfs_set_acl()
93 acl = NULL; __jfs_set_acl()
103 if (acl) { __jfs_set_acl()
104 size = posix_acl_xattr_size(acl->a_count); __jfs_set_acl()
108 rc = posix_acl_to_xattr(&init_user_ns, acl, value, size); __jfs_set_acl()
117 set_cached_acl(inode, type, acl); __jfs_set_acl()
122 int jfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) jfs_set_acl() argument
129 rc = __jfs_set_acl(tid, inode, type, acl); jfs_set_acl()
139 struct posix_acl *default_acl, *acl; jfs_init_acl() local
142 rc = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); jfs_init_acl()
151 if (acl) { jfs_init_acl()
153 rc = __jfs_set_acl(tid, inode, ACL_TYPE_ACCESS, acl); jfs_init_acl()
154 posix_acl_release(acl); jfs_init_acl()
75 __jfs_set_acl(tid_t tid, struct inode *inode, int type, struct posix_acl *acl) __jfs_set_acl() argument
|
| H A D | Makefile | 14 jfs-$(CONFIG_JFS_POSIX_ACL) += acl.o
|
| H A D | jfs_acl.h | 24 int jfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | jfs_incore.h | 44 dxd_t acl; /* dxd describing acl */ member in struct:jfs_inode_info
|
| H A D | namei.c | 423 if (JFS_IP(ip)->acl.flag & DXD_EXTENT) { jfs_rmdir()
425 txEA(tid, ip, &JFS_IP(ip)->acl, NULL); jfs_rmdir()
427 JFS_IP(ip)->acl.flag = 0; jfs_rmdir()
677 if (JFS_IP(ip)->acl.flag & DXD_EXTENT) commitZeroLink()
679 txEA(tid, ip, &JFS_IP(ip)->acl, NULL); commitZeroLink()
751 if (JFS_IP(ip)->acl.flag & DXD_EXTENT) { jfs_free_zero_link()
752 s64 xaddr = addressDXD(&JFS_IP(ip)->acl); jfs_free_zero_link()
753 int xlen = lengthDXD(&JFS_IP(ip)->acl); jfs_free_zero_link()
757 invalidate_dxd_metapages(ip, JFS_IP(ip)->acl); jfs_free_zero_link()
|
| H A D | jfs_inode.c | 141 memset(&jfs_inode->acl, 0, sizeof(dxd_t)); ialloc()
|
| H A D | jfs_dinode.h | 64 dxd_t di_acl; /* 16: acl descriptor */
|
| H A D | jfs_imap.c | 3095 jfs_ip->acl = dip->di_acl; /* as are dxd's */ copy_from_dinode()
3170 dip->di_acl = jfs_ip->acl; /* as are dxd's */ copy_to_dinode()
|
| /linux-4.4.14/fs/btrfs/ |
| H A D | acl.c | 36 struct posix_acl *acl; btrfs_get_acl() local
57 acl = posix_acl_from_xattr(&init_user_ns, value, size); btrfs_get_acl()
60 acl = NULL; btrfs_get_acl()
62 acl = ERR_PTR(-EIO); btrfs_get_acl()
66 if (!IS_ERR(acl)) btrfs_get_acl()
67 set_cached_acl(inode, type, acl); btrfs_get_acl()
69 return acl; btrfs_get_acl()
76 struct inode *inode, struct posix_acl *acl, int type) __btrfs_set_acl()
85 if (acl) { __btrfs_set_acl()
86 ret = posix_acl_equiv_mode(acl, &inode->i_mode); __btrfs_set_acl()
90 acl = NULL; __btrfs_set_acl()
96 return acl ? -EINVAL : 0; __btrfs_set_acl()
103 if (acl) { __btrfs_set_acl()
104 size = posix_acl_xattr_size(acl->a_count); __btrfs_set_acl()
111 ret = posix_acl_to_xattr(&init_user_ns, acl, value, size); __btrfs_set_acl()
121 set_cached_acl(inode, type, acl); __btrfs_set_acl()
126 int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) btrfs_set_acl() argument
128 return __btrfs_set_acl(NULL, inode, acl, type); btrfs_set_acl()
134 * need to re-evaluate the acl locking stuff.
139 struct posix_acl *default_acl, *acl; btrfs_init_acl() local
146 ret = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); btrfs_init_acl()
156 if (acl) { btrfs_init_acl()
158 ret = __btrfs_set_acl(trans, inode, acl, btrfs_init_acl()
160 posix_acl_release(acl); btrfs_init_acl()
163 if (!default_acl && !acl) btrfs_init_acl()
75 __btrfs_set_acl(struct btrfs_trans_handle *trans, struct inode *inode, struct posix_acl *acl, int type) __btrfs_set_acl() argument
|
| H A D | send.c | 4194 * This hack is needed because empty acl's are stored as zero byte __process_new_xattr()
4196 * acl's will fail later. To fix this, we send a dummy acl list that __process_new_xattr()
|
| H A D | super.c | 333 {Opt_acl, "acl"},
|
| H A D | ctree.h | 4298 /* acl.c */
4301 int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | inode.c | 3564 /* we found an xattr, assume we've got an acl */ acls_after_inode_item()
3738 * try to precache a NULL acl entry for files that don't have btrfs_read_locked_inode()
|
| /linux-4.4.14/fs/ceph/ |
| H A D | acl.c | 2 * linux/fs/ceph/acl.c
33 int type, struct posix_acl *acl) ceph_set_cached_acl()
39 set_cached_acl(inode, type, acl); ceph_set_cached_acl()
48 struct posix_acl *acl; ceph_get_acl() local
70 acl = posix_acl_from_xattr(&init_user_ns, value, size); ceph_get_acl()
72 acl = NULL; ceph_get_acl()
74 acl = ERR_PTR(-EIO); ceph_get_acl()
78 if (!IS_ERR(acl)) ceph_get_acl()
79 ceph_set_cached_acl(inode, type, acl); ceph_get_acl()
81 return acl; ceph_get_acl()
84 int ceph_set_acl(struct inode *inode, struct posix_acl *acl, int type) ceph_set_acl() argument
96 if (acl) { ceph_set_acl()
97 ret = posix_acl_equiv_mode(acl, &new_mode); ceph_set_acl()
101 acl = NULL; ceph_set_acl()
106 ret = acl ? -EINVAL : 0; ceph_set_acl()
116 if (acl) { ceph_set_acl()
117 size = posix_acl_xattr_size(acl->a_count); ceph_set_acl()
124 ret = posix_acl_to_xattr(&init_user_ns, acl, value, size); ceph_set_acl()
148 ceph_set_cached_acl(inode, type, acl); ceph_set_acl()
161 struct posix_acl *acl, *default_acl; ceph_pre_init_acls() local
167 err = posix_acl_create(dir, mode, &default_acl, &acl); ceph_pre_init_acls()
171 if (acl) { ceph_pre_init_acls()
172 int ret = posix_acl_equiv_mode(acl, mode); ceph_pre_init_acls()
176 posix_acl_release(acl); ceph_pre_init_acls()
177 acl = NULL; ceph_pre_init_acls()
181 if (!default_acl && !acl) ceph_pre_init_acls()
184 if (acl) ceph_pre_init_acls()
185 val_size1 = posix_acl_xattr_size(acl->a_count); ceph_pre_init_acls()
202 ceph_pagelist_encode_32(pagelist, acl && default_acl ? 2 : 1); ceph_pre_init_acls()
204 if (acl) { ceph_pre_init_acls()
211 err = posix_acl_to_xattr(&init_user_ns, acl, ceph_pre_init_acls()
235 info->acl = acl; ceph_pre_init_acls()
241 posix_acl_release(acl); ceph_pre_init_acls()
253 ceph_set_cached_acl(inode, ACL_TYPE_ACCESS, info->acl); ceph_init_inode_acls()
259 posix_acl_release(info->acl); ceph_release_acls_info()
32 ceph_set_cached_acl(struct inode *inode, int type, struct posix_acl *acl) ceph_set_cached_acl() argument
|
| H A D | Makefile | 13 ceph-$(CONFIG_CEPH_FS_POSIX_ACL) += acl.o
|
| H A D | super.c | 173 {Opt_acl, "acl"},
455 seq_puts(m, ",acl"); ceph_show_options()
|
| H A D | super.h | 810 /* acl.c */
813 void *acl; member in struct:ceph_acls_info
820 int ceph_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| /linux-4.4.14/fs/f2fs/ |
| H A D | acl.c | 2 * fs/f2fs/acl.c
7 * Portions of this code from linux/fs/ext2/acl.c
18 #include "acl.h"
51 struct posix_acl *acl; f2fs_acl_from_disk() local
65 acl = posix_acl_alloc(count, GFP_NOFS); f2fs_acl_from_disk()
66 if (!acl) f2fs_acl_from_disk()
74 acl->a_entries[i].e_tag = le16_to_cpu(entry->e_tag); f2fs_acl_from_disk()
75 acl->a_entries[i].e_perm = le16_to_cpu(entry->e_perm); f2fs_acl_from_disk()
77 switch (acl->a_entries[i].e_tag) { f2fs_acl_from_disk()
87 acl->a_entries[i].e_uid = f2fs_acl_from_disk()
94 acl->a_entries[i].e_gid = f2fs_acl_from_disk()
106 return acl; f2fs_acl_from_disk()
108 posix_acl_release(acl); f2fs_acl_from_disk()
112 static void *f2fs_acl_to_disk(const struct posix_acl *acl, size_t *size) f2fs_acl_to_disk() argument
118 f2fs_acl = kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count * f2fs_acl_to_disk()
126 for (i = 0; i < acl->a_count; i++) { f2fs_acl_to_disk()
128 entry->e_tag = cpu_to_le16(acl->a_entries[i].e_tag); f2fs_acl_to_disk()
129 entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm); f2fs_acl_to_disk()
131 switch (acl->a_entries[i].e_tag) { f2fs_acl_to_disk()
135 acl->a_entries[i].e_uid)); f2fs_acl_to_disk()
142 acl->a_entries[i].e_gid)); f2fs_acl_to_disk()
157 *size = f2fs_acl_size(acl->a_count); f2fs_acl_to_disk()
170 struct posix_acl *acl; __f2fs_get_acl() local
186 acl = f2fs_acl_from_disk(value, retval); __f2fs_get_acl()
188 acl = NULL; __f2fs_get_acl()
190 acl = ERR_PTR(retval); __f2fs_get_acl()
193 if (!IS_ERR(acl)) __f2fs_get_acl()
194 set_cached_acl(inode, type, acl); __f2fs_get_acl()
196 return acl; __f2fs_get_acl()
205 struct posix_acl *acl, struct page *ipage) __f2fs_set_acl()
216 if (acl) { __f2fs_set_acl()
217 error = posix_acl_equiv_mode(acl, &inode->i_mode); __f2fs_set_acl()
222 acl = NULL; __f2fs_set_acl()
229 return acl ? -EACCES : 0; __f2fs_set_acl()
236 if (acl) { __f2fs_set_acl()
237 value = f2fs_acl_to_disk(acl, &size); __f2fs_set_acl()
248 set_cached_acl(inode, type, acl); __f2fs_set_acl()
254 int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type) f2fs_set_acl() argument
256 return __f2fs_set_acl(inode, type, acl, NULL); f2fs_set_acl()
263 static struct posix_acl *f2fs_acl_clone(const struct posix_acl *acl, f2fs_acl_clone() argument
268 if (acl) { f2fs_acl_clone()
269 int size = sizeof(struct posix_acl) + acl->a_count * f2fs_acl_clone()
271 clone = kmemdup(acl, size, flags); f2fs_acl_clone()
278 static int f2fs_acl_create_masq(struct posix_acl *acl, umode_t *mode_p) f2fs_acl_create_masq() argument
285 /* assert(atomic_read(acl->a_refcount) == 1); */ f2fs_acl_create_masq()
287 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
333 struct posix_acl **default_acl, struct posix_acl **acl, f2fs_acl_create()
340 *acl = NULL; f2fs_acl_create()
365 *acl = clone; f2fs_acl_create()
384 struct posix_acl *default_acl = NULL, *acl = NULL; f2fs_init_acl() local
387 error = f2fs_acl_create(dir, &inode->i_mode, &default_acl, &acl, dpage); f2fs_init_acl()
396 if (acl) { f2fs_init_acl()
398 error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl, f2fs_init_acl()
400 posix_acl_release(acl); f2fs_init_acl()
204 __f2fs_set_acl(struct inode *inode, int type, struct posix_acl *acl, struct page *ipage) __f2fs_set_acl() argument
332 f2fs_acl_create(struct inode *dir, umode_t *mode, struct posix_acl **default_acl, struct posix_acl **acl, struct page *dpage) f2fs_acl_create() argument
|
| H A D | Makefile | 8 f2fs-$(CONFIG_F2FS_FS_POSIX_ACL) += acl.o
|
| H A D | acl.h | 2 * fs/f2fs/acl.h
7 * Portions of this code from linux/fs/ext2/acl.h
40 extern int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | super.c | 81 {Opt_acl, "acl"},
369 f2fs_msg(sb, KERN_INFO, "acl options not supported"); parse_options()
667 seq_puts(seq, ",acl"); f2fs_show_options()
|
| H A D | dir.c | 15 #include "acl.h"
|
| H A D | namei.c | 22 #include "acl.h"
|
| H A D | f2fs.h | 427 umode_t i_acl_mode; /* keep file acl mode temporarily */
1401 FI_ACL_MODE, /* indicate acl mode */
|
| H A D | file.c | 29 #include "acl.h"
|
| /linux-4.4.14/fs/ |
| H A D | posix_acl.c | 40 struct posix_acl *acl = ACCESS_ONCE(*p); get_cached_acl() local
41 if (acl) { get_cached_acl()
43 acl = *p; get_cached_acl()
44 if (acl != ACL_NOT_CACHED) get_cached_acl()
45 acl = posix_acl_dup(acl); get_cached_acl()
48 return acl; get_cached_acl()
58 void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl) set_cached_acl() argument
64 rcu_assign_pointer(*p, posix_acl_dup(acl)); set_cached_acl()
101 struct posix_acl *acl; get_acl() local
103 acl = get_cached_acl(inode, type); get_acl()
104 if (acl != ACL_NOT_CACHED) get_acl()
105 return acl; get_acl()
130 posix_acl_init(struct posix_acl *acl, int count) posix_acl_init() argument
132 atomic_set(&acl->a_refcount, 1); posix_acl_init()
133 acl->a_count = count; posix_acl_init()
145 struct posix_acl *acl = kmalloc(size, flags); posix_acl_alloc() local
146 if (acl) posix_acl_alloc()
147 posix_acl_init(acl, count); posix_acl_alloc()
148 return acl; posix_acl_alloc()
156 posix_acl_clone(const struct posix_acl *acl, gfp_t flags) posix_acl_clone() argument
160 if (acl) { posix_acl_clone()
161 int size = sizeof(struct posix_acl) + acl->a_count * posix_acl_clone()
163 clone = kmemdup(acl, size, flags); posix_acl_clone()
171 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
174 posix_acl_valid(const struct posix_acl *acl) posix_acl_valid() argument
180 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
239 * Returns 0 if the acl can be exactly represented in the traditional
243 posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p) posix_acl_equiv_mode() argument
252 if (!acl) posix_acl_equiv_mode()
255 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
291 struct posix_acl *acl = posix_acl_alloc(3, flags); posix_acl_from_mode() local
292 if (!acl) posix_acl_from_mode()
295 acl->a_entries[0].e_tag = ACL_USER_OBJ; posix_acl_from_mode()
296 acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6; posix_acl_from_mode()
298 acl->a_entries[1].e_tag = ACL_GROUP_OBJ; posix_acl_from_mode()
299 acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3; posix_acl_from_mode()
301 acl->a_entries[2].e_tag = ACL_OTHER; posix_acl_from_mode()
302 acl->a_entries[2].e_perm = (mode & S_IRWXO); posix_acl_from_mode()
303 return acl; posix_acl_from_mode()
309 * by the acl. Returns -E... otherwise.
312 posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want) posix_acl_permission() argument
319 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
373 * Modify acl when creating a new inode. The caller must ensure the acl is
377 * system calls. All permissions that are not granted by the acl are removed.
378 * The permissions in the acl are changed to reflect the mode_p parameter.
380 static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p) posix_acl_create_masq() argument
387 /* assert(atomic_read(acl->a_refcount) == 1); */ posix_acl_create_masq()
389 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
437 static int __posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode) __posix_acl_chmod_masq() argument
442 /* assert(atomic_read(acl->a_refcount) == 1); */ __posix_acl_chmod_masq()
444 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
483 __posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p) __posix_acl_create() argument
485 struct posix_acl *clone = posix_acl_clone(*acl, gfp); __posix_acl_create()
494 posix_acl_release(*acl); __posix_acl_create()
495 *acl = clone; __posix_acl_create()
501 __posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode) __posix_acl_chmod() argument
503 struct posix_acl *clone = posix_acl_clone(*acl, gfp); __posix_acl_chmod()
512 posix_acl_release(*acl); __posix_acl_chmod()
513 *acl = clone; __posix_acl_chmod()
521 struct posix_acl *acl; posix_acl_chmod() local
529 acl = get_acl(inode, ACL_TYPE_ACCESS); posix_acl_chmod()
530 if (IS_ERR_OR_NULL(acl)) { posix_acl_chmod()
531 if (acl == ERR_PTR(-EOPNOTSUPP)) posix_acl_chmod()
533 return PTR_ERR(acl); posix_acl_chmod()
536 ret = __posix_acl_chmod(&acl, GFP_KERNEL, mode); posix_acl_chmod()
539 ret = inode->i_op->set_acl(inode, acl, ACL_TYPE_ACCESS); posix_acl_chmod()
540 posix_acl_release(acl); posix_acl_chmod()
547 struct posix_acl **default_acl, struct posix_acl **acl) posix_acl_create()
553 *acl = NULL; posix_acl_create()
578 *acl = clone; posix_acl_create()
596 * Fix up the uids and gids in posix acl extended attributes in place.
663 struct posix_acl *acl; posix_acl_from_xattr() local
679 acl = posix_acl_alloc(count, GFP_NOFS); posix_acl_from_xattr()
680 if (!acl) posix_acl_from_xattr()
682 acl_e = acl->a_entries; posix_acl_from_xattr()
714 return acl; posix_acl_from_xattr()
717 posix_acl_release(acl); posix_acl_from_xattr()
726 posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl, posix_acl_to_xattr() argument
733 real_size = posix_acl_xattr_size(acl->a_count); posix_acl_to_xattr()
742 for (n=0; n < acl->a_count; n++, ext_entry++) { posix_acl_to_xattr()
743 const struct posix_acl_entry *acl_e = &acl->a_entries[n]; posix_acl_to_xattr()
769 struct posix_acl *acl; posix_acl_xattr_get() local
779 acl = get_acl(d_backing_inode(dentry), handler->flags); posix_acl_xattr_get()
780 if (IS_ERR(acl)) posix_acl_xattr_get()
781 return PTR_ERR(acl); posix_acl_xattr_get()
782 if (acl == NULL) posix_acl_xattr_get()
785 error = posix_acl_to_xattr(&init_user_ns, acl, value, size); posix_acl_xattr_get()
786 posix_acl_release(acl); posix_acl_xattr_get()
797 struct posix_acl *acl = NULL; posix_acl_xattr_set() local
813 acl = posix_acl_from_xattr(&init_user_ns, value, size); posix_acl_xattr_set()
814 if (IS_ERR(acl)) posix_acl_xattr_set()
815 return PTR_ERR(acl); posix_acl_xattr_set()
817 if (acl) { posix_acl_xattr_set()
818 ret = posix_acl_valid(acl); posix_acl_xattr_set()
824 ret = inode->i_op->set_acl(inode, acl, handler->flags); posix_acl_xattr_set()
826 posix_acl_release(acl); posix_acl_xattr_set()
865 int simple_set_acl(struct inode *inode, struct posix_acl *acl, int type) simple_set_acl() argument
870 error = posix_acl_equiv_mode(acl, &inode->i_mode); simple_set_acl()
874 acl = NULL; simple_set_acl()
878 set_cached_acl(inode, type, acl); simple_set_acl()
884 struct posix_acl *default_acl, *acl; simple_acl_create() local
887 error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); simple_acl_create()
892 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); simple_acl_create()
896 if (acl) simple_acl_create()
897 posix_acl_release(acl); simple_acl_create()
546 posix_acl_create(struct inode *dir, umode_t *mode, struct posix_acl **default_acl, struct posix_acl **acl) posix_acl_create() argument
|
| H A D | namei.c | 261 struct posix_acl *acl; check_acl() local
264 acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS); check_acl()
265 if (!acl) check_acl()
268 if (acl == ACL_NOT_CACHED) check_acl()
270 return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK); check_acl()
273 acl = get_acl(inode, ACL_TYPE_ACCESS); check_acl()
274 if (IS_ERR(acl)) check_acl()
275 return PTR_ERR(acl); check_acl()
276 if (acl) { check_acl()
277 int error = posix_acl_permission(inode, acl, mask); check_acl()
278 posix_acl_release(acl); check_acl()
|
| /linux-4.4.14/drivers/target/iscsi/ |
| H A D | iscsi_target_nodeattrib.c | 36 struct iscsi_node_acl *acl, iscsit_set_default_node_attribues()
39 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_set_default_node_attribues()
52 struct iscsi_node_acl *acl, iscsit_na_dataout_timeout()
55 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_dataout_timeout()
71 " %s\n", a->dataout_timeout, iscsit_na_get_initiatorname(acl)); iscsit_na_dataout_timeout()
77 struct iscsi_node_acl *acl, iscsit_na_dataout_timeout_retries()
80 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_dataout_timeout_retries()
97 iscsit_na_get_initiatorname(acl)); iscsit_na_dataout_timeout_retries()
103 struct iscsi_node_acl *acl, iscsit_na_nopin_timeout()
106 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_nopin_timeout()
128 iscsit_na_get_initiatorname(acl)); iscsit_na_nopin_timeout()
158 struct iscsi_node_acl *acl, iscsit_na_nopin_response_timeout()
161 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_nopin_response_timeout()
178 iscsit_na_get_initiatorname(acl)); iscsit_na_nopin_response_timeout()
184 struct iscsi_node_acl *acl, iscsit_na_random_datain_pdu_offsets()
187 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_random_datain_pdu_offsets()
198 iscsit_na_get_initiatorname(acl)); iscsit_na_random_datain_pdu_offsets()
204 struct iscsi_node_acl *acl, iscsit_na_random_datain_seq_offsets()
207 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_random_datain_seq_offsets()
218 iscsit_na_get_initiatorname(acl)); iscsit_na_random_datain_seq_offsets()
224 struct iscsi_node_acl *acl, iscsit_na_random_r2t_offsets()
227 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_random_r2t_offsets()
238 iscsit_na_get_initiatorname(acl)); iscsit_na_random_r2t_offsets()
244 struct iscsi_node_acl *acl, iscsit_na_default_erl()
247 struct iscsi_node_attrib *a = &acl->node_attrib; iscsit_na_default_erl()
258 iscsit_na_get_initiatorname(acl)); iscsit_na_default_erl()
35 iscsit_set_default_node_attribues( struct iscsi_node_acl *acl, struct iscsi_portal_group *tpg) iscsit_set_default_node_attribues() argument
51 iscsit_na_dataout_timeout( struct iscsi_node_acl *acl, u32 dataout_timeout) iscsit_na_dataout_timeout() argument
76 iscsit_na_dataout_timeout_retries( struct iscsi_node_acl *acl, u32 dataout_timeout_retries) iscsit_na_dataout_timeout_retries() argument
102 iscsit_na_nopin_timeout( struct iscsi_node_acl *acl, u32 nopin_timeout) iscsit_na_nopin_timeout() argument
157 iscsit_na_nopin_response_timeout( struct iscsi_node_acl *acl, u32 nopin_response_timeout) iscsit_na_nopin_response_timeout() argument
183 iscsit_na_random_datain_pdu_offsets( struct iscsi_node_acl *acl, u32 random_datain_pdu_offsets) iscsit_na_random_datain_pdu_offsets() argument
203 iscsit_na_random_datain_seq_offsets( struct iscsi_node_acl *acl, u32 random_datain_seq_offsets) iscsit_na_random_datain_seq_offsets() argument
223 iscsit_na_random_r2t_offsets( struct iscsi_node_acl *acl, u32 random_r2t_offsets) iscsit_na_random_r2t_offsets() argument
243 iscsit_na_default_erl( struct iscsi_node_acl *acl, u32 default_erl) iscsit_na_default_erl() argument
|
| H A D | iscsi_target_stat.c | 599 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_inst_show() local
600 struct se_wwn *wwn = acl->se_node_acl.se_tpg->se_tpg_wwn; iscsi_stat_sess_inst_show()
609 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_node_show() local
610 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_node_show()
630 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_indx_show() local
631 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_indx_show()
652 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_cmd_pdus_show() local
653 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_cmd_pdus_show()
674 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_rsp_pdus_show() local
675 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_rsp_pdus_show()
696 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_txdata_octs_show() local
697 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_txdata_octs_show()
718 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_rxdata_octs_show() local
719 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_rxdata_octs_show()
740 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_conn_digest_errors_show() local
741 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_conn_digest_errors_show()
762 struct iscsi_node_acl *acl = iscsi_stat_nacl(item); iscsi_stat_sess_conn_timeout_errors_show() local
763 struct se_node_acl *se_nacl = &acl->se_node_acl; iscsi_stat_sess_conn_timeout_errors_show()
|
| H A D | iscsi_target_configfs.c | 775 struct iscsi_node_acl *acl = lio_target_init_nodeacl() local
787 stats_cg->default_groups[0] = &acl->node_stat_grps.iscsi_sess_stats_group; lio_target_init_nodeacl()
789 config_group_init_type_name(&acl->node_stat_grps.iscsi_sess_stats_group, lio_target_init_nodeacl()
797 struct iscsi_node_acl *acl = container_of(se_nacl, lio_target_cleanup_nodeacl() local
803 stats_cg = &acl->se_node_acl.acl_fabric_stat_group; lio_target_cleanup_nodeacl()
1656 struct iscsi_node_acl *acl = container_of(se_acl, struct iscsi_node_acl, lio_set_default_node_attributes() local
1662 acl->node_attrib.nacl = acl; lio_set_default_node_attributes()
1663 iscsit_set_default_node_attribues(acl, tpg); lio_set_default_node_attributes()
|
| H A D | iscsi_target_tpg.c | 406 struct iscsi_node_acl *acl = container_of(se_nacl, struct iscsi_node_acl, iscsit_tpg_get_node_attrib() local
409 return &acl->node_attrib; iscsit_tpg_get_node_attrib()
|
| /linux-4.4.14/fs/gfs2/ |
| H A D | acl.c | 22 #include "acl.h"
44 struct posix_acl *acl; gfs2_get_acl() local
62 acl = posix_acl_from_xattr(&init_user_ns, data, len); gfs2_get_acl()
64 return acl; gfs2_get_acl()
67 int gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) gfs2_set_acl() argument
76 if (acl && acl->a_count > GFS2_ACL_MAX_ENTRIES(GFS2_SB(inode))) gfs2_set_acl()
82 error = posix_acl_equiv_mode(acl, &mode); gfs2_set_acl()
87 acl = NULL; gfs2_set_acl()
95 if (acl) { gfs2_set_acl()
96 len = posix_acl_to_xattr(&init_user_ns, acl, NULL, 0); gfs2_set_acl()
102 error = posix_acl_to_xattr(&init_user_ns, acl, data, len); gfs2_set_acl()
113 set_cached_acl(inode, type, acl); gfs2_set_acl()
|
| H A D | Makefile | 3 gfs2-y := acl.o bmap.o dir.o xattr.o glock.o \
|
| H A D | acl.h | 20 extern int gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | xattr.h | 62 /* Exported to acl.c */
|
| H A D | inode.c | 26 #include "acl.h"
590 struct posix_acl *default_acl, *acl; gfs2_create_inode() local
651 error = posix_acl_create(dir, &mode, &default_acl, &acl); gfs2_create_inode()
694 if (default_acl || acl) gfs2_create_inode()
740 if (acl) { gfs2_create_inode()
742 error = gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS); gfs2_create_inode()
743 posix_acl_release(acl); gfs2_create_inode()
783 if (acl) gfs2_create_inode()
784 posix_acl_release(acl); gfs2_create_inode()
|
| H A D | super.c | 101 {Opt_acl, "acl"},
1349 seq_puts(s, ",acl"); gfs2_show_options()
|
| H A D | xattr.c | 21 #include "acl.h"
|
| /linux-4.4.14/fs/reiserfs/ |
| H A D | xattr_acl.c | 11 #include "acl.h"
16 struct posix_acl *acl);
20 reiserfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) reiserfs_set_acl() argument
25 int size = acl ? posix_acl_xattr_size(acl->a_count) : 0; reiserfs_set_acl()
40 error = __reiserfs_set_acl(&th, inode, type, acl); reiserfs_set_acl()
58 struct posix_acl *acl; reiserfs_posix_acl_from_disk() local
73 acl = posix_acl_alloc(count, GFP_NOFS); reiserfs_posix_acl_from_disk()
74 if (!acl) reiserfs_posix_acl_from_disk()
80 acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); reiserfs_posix_acl_from_disk()
81 acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); reiserfs_posix_acl_from_disk()
82 switch (acl->a_entries[n].e_tag) { reiserfs_posix_acl_from_disk()
95 acl->a_entries[n].e_uid = reiserfs_posix_acl_from_disk()
103 acl->a_entries[n].e_gid = reiserfs_posix_acl_from_disk()
114 return acl; reiserfs_posix_acl_from_disk()
117 posix_acl_release(acl); reiserfs_posix_acl_from_disk()
124 static void *reiserfs_posix_acl_to_disk(const struct posix_acl *acl, size_t * size) reiserfs_posix_acl_to_disk() argument
130 *size = reiserfs_acl_size(acl->a_count); reiserfs_posix_acl_to_disk()
132 acl->a_count * reiserfs_posix_acl_to_disk()
139 for (n = 0; n < acl->a_count; n++) { reiserfs_posix_acl_to_disk()
140 const struct posix_acl_entry *acl_e = &acl->a_entries[n]; reiserfs_posix_acl_to_disk()
142 entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag); reiserfs_posix_acl_to_disk()
143 entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm); reiserfs_posix_acl_to_disk()
144 switch (acl->a_entries[n].e_tag) { reiserfs_posix_acl_to_disk()
183 struct posix_acl *acl; reiserfs_get_acl() local
217 acl = NULL; reiserfs_get_acl()
219 acl = ERR_PTR(retval); reiserfs_get_acl()
221 acl = reiserfs_posix_acl_from_disk(value, retval); reiserfs_get_acl()
223 if (!IS_ERR(acl)) reiserfs_get_acl()
224 set_cached_acl(inode, type, acl); reiserfs_get_acl()
227 return acl; reiserfs_get_acl()
238 int type, struct posix_acl *acl) __reiserfs_set_acl()
248 if (acl) { __reiserfs_set_acl()
249 error = posix_acl_equiv_mode(acl, &inode->i_mode); __reiserfs_set_acl()
254 acl = NULL; __reiserfs_set_acl()
261 return acl ? -EACCES : 0; __reiserfs_set_acl()
267 if (acl) { __reiserfs_set_acl()
268 value = reiserfs_posix_acl_to_disk(acl, &size); __reiserfs_set_acl()
292 set_cached_acl(inode, type, acl); __reiserfs_set_acl()
306 struct posix_acl *default_acl, *acl; reiserfs_inherit_default_acl() local
330 err = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); reiserfs_inherit_default_acl()
339 if (acl) { reiserfs_inherit_default_acl()
342 acl); reiserfs_inherit_default_acl()
343 posix_acl_release(acl); reiserfs_inherit_default_acl()
354 /* This is used to cache the default acl before a new object is created.
367 struct posix_acl *acl; reiserfs_cache_default_acl() local
373 acl = reiserfs_get_acl(inode, ACL_TYPE_DEFAULT); reiserfs_cache_default_acl()
375 if (acl && !IS_ERR(acl)) { reiserfs_cache_default_acl()
376 int size = reiserfs_acl_size(acl->a_count); reiserfs_cache_default_acl()
389 posix_acl_release(acl); reiserfs_cache_default_acl()
237 __reiserfs_set_acl(struct reiserfs_transaction_handle *th, struct inode *inode, int type, struct posix_acl *acl) __reiserfs_set_acl() argument
|
| H A D | acl.h | 51 int reiserfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | file.c | 7 #include "acl.h"
|
| H A D | super.c | 20 #include "acl.h"
714 seq_puts(seq, ",acl"); reiserfs_show_options()
1107 {"acl",.setmask = 1 << REISERFS_POSIXACL}, reiserfs_parse_options()
1110 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT}, reiserfs_parse_options()
|
| H A D | xattr.c | 47 #include "acl.h"
1057 /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */ reiserfs_xattr_init()
|
| H A D | namei.c | 18 #include "acl.h"
1678 * special file operations.. just xattr/acl stuff
|
| H A D | inode.c | 8 #include "acl.h"
|
| /linux-4.4.14/fs/jffs2/ |
| H A D | acl.c | 60 struct posix_acl *acl; jffs2_acl_from_medium() local
81 acl = posix_acl_alloc(count, GFP_KERNEL); jffs2_acl_from_medium()
82 if (!acl) jffs2_acl_from_medium()
89 acl->a_entries[i].e_tag = je16_to_cpu(entry->e_tag); jffs2_acl_from_medium()
90 acl->a_entries[i].e_perm = je16_to_cpu(entry->e_perm); jffs2_acl_from_medium()
91 switch (acl->a_entries[i].e_tag) { jffs2_acl_from_medium()
103 acl->a_entries[i].e_uid = jffs2_acl_from_medium()
111 acl->a_entries[i].e_gid = jffs2_acl_from_medium()
122 return acl; jffs2_acl_from_medium()
124 posix_acl_release(acl); jffs2_acl_from_medium()
128 static void *jffs2_acl_to_medium(const struct posix_acl *acl, size_t *size) jffs2_acl_to_medium() argument
135 *size = jffs2_acl_size(acl->a_count); jffs2_acl_to_medium()
136 header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL); jffs2_acl_to_medium()
141 for (i=0; i < acl->a_count; i++) { jffs2_acl_to_medium()
142 const struct posix_acl_entry *acl_e = &acl->a_entries[i]; jffs2_acl_to_medium()
177 struct posix_acl *acl; jffs2_get_acl() local
199 acl = jffs2_acl_from_medium(value, rc); jffs2_get_acl()
201 acl = NULL; jffs2_get_acl()
203 acl = ERR_PTR(rc); jffs2_get_acl()
206 if (!IS_ERR(acl)) jffs2_get_acl()
207 set_cached_acl(inode, type, acl); jffs2_get_acl()
208 return acl; jffs2_get_acl()
211 static int __jffs2_set_acl(struct inode *inode, int xprefix, struct posix_acl *acl) __jffs2_set_acl() argument
217 if (acl) { __jffs2_set_acl()
218 value = jffs2_acl_to_medium(acl, &size); __jffs2_set_acl()
230 int jffs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) jffs2_set_acl() argument
237 if (acl) { jffs2_set_acl()
239 rc = posix_acl_equiv_mode(acl, &mode); jffs2_set_acl()
253 acl = NULL; jffs2_set_acl()
259 return acl ? -EACCES : 0; jffs2_set_acl()
264 rc = __jffs2_set_acl(inode, xprefix, acl); jffs2_set_acl()
266 set_cached_acl(inode, type, acl); jffs2_set_acl()
272 struct posix_acl *default_acl, *acl; jffs2_init_acl_pre() local
277 rc = posix_acl_create(dir_i, i_mode, &default_acl, &acl); jffs2_init_acl_pre()
285 if (acl) { jffs2_init_acl_pre()
286 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); jffs2_init_acl_pre()
287 posix_acl_release(acl); jffs2_init_acl_pre()
|
| H A D | Makefile | 16 jffs2-$(CONFIG_JFFS2_FS_POSIX_ACL) += acl.o
|
| H A D | acl.h | 30 int jffs2_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | nodelist.h | 21 #include "acl.h"
|
| /linux-4.4.14/drivers/target/ |
| H A D | target_core_tpg.c | 59 struct se_node_acl *acl; __core_tpg_get_initiator_node_acl() local
61 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) { __core_tpg_get_initiator_node_acl()
62 if (!strcmp(acl->initiatorname, initiatorname)) __core_tpg_get_initiator_node_acl()
63 return acl; __core_tpg_get_initiator_node_acl()
77 struct se_node_acl *acl; core_tpg_get_initiator_node_acl() local
80 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname); core_tpg_get_initiator_node_acl()
83 return acl; core_tpg_get_initiator_node_acl()
108 struct se_node_acl *acl, core_tpg_add_node_to_devs()
148 lun_access, acl, tpg); core_tpg_add_node_to_devs()
154 core_scsi3_check_aptpl_registration(dev, tpg, lun, acl, core_tpg_add_node_to_devs()
166 struct se_node_acl *acl) core_set_queue_depth_for_node()
168 if (!acl->queue_depth) { core_set_queue_depth_for_node()
171 acl->initiatorname); core_set_queue_depth_for_node()
172 acl->queue_depth = 1; core_set_queue_depth_for_node()
181 struct se_node_acl *acl; target_alloc_node_acl() local
183 acl = kzalloc(max(sizeof(*acl), tpg->se_tpg_tfo->node_acl_size), target_alloc_node_acl()
185 if (!acl) target_alloc_node_acl()
188 INIT_LIST_HEAD(&acl->acl_list); target_alloc_node_acl()
189 INIT_LIST_HEAD(&acl->acl_sess_list); target_alloc_node_acl()
190 INIT_HLIST_HEAD(&acl->lun_entry_hlist); target_alloc_node_acl()
191 kref_init(&acl->acl_kref); target_alloc_node_acl()
192 init_completion(&acl->acl_free_comp); target_alloc_node_acl()
193 spin_lock_init(&acl->nacl_sess_lock); target_alloc_node_acl()
194 mutex_init(&acl->lun_entry_mutex); target_alloc_node_acl()
195 atomic_set(&acl->acl_pr_ref_count, 0); target_alloc_node_acl()
197 acl->queue_depth = tpg->se_tpg_tfo->tpg_get_default_depth(tpg); target_alloc_node_acl()
199 acl->queue_depth = 1; target_alloc_node_acl()
200 snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname); target_alloc_node_acl()
201 acl->se_tpg = tpg; target_alloc_node_acl()
202 acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX); target_alloc_node_acl()
204 tpg->se_tpg_tfo->set_default_node_attributes(acl); target_alloc_node_acl()
206 if (core_set_queue_depth_for_node(tpg, acl) < 0) target_alloc_node_acl()
209 return acl; target_alloc_node_acl()
212 kfree(acl); target_alloc_node_acl()
216 static void target_add_node_acl(struct se_node_acl *acl) target_add_node_acl() argument
218 struct se_portal_group *tpg = acl->se_tpg; target_add_node_acl()
221 list_add_tail(&acl->acl_list, &tpg->acl_node_list); target_add_node_acl()
229 acl->dynamic_node_acl ? "DYNAMIC" : "", target_add_node_acl()
230 acl->queue_depth, target_add_node_acl()
232 acl->initiatorname); target_add_node_acl()
239 struct se_node_acl *acl; core_tpg_check_initiator_node_acl() local
241 acl = core_tpg_get_initiator_node_acl(tpg, initiatorname); core_tpg_check_initiator_node_acl()
242 if (acl) core_tpg_check_initiator_node_acl()
243 return acl; core_tpg_check_initiator_node_acl()
248 acl = target_alloc_node_acl(tpg, initiatorname); core_tpg_check_initiator_node_acl()
249 if (!acl) core_tpg_check_initiator_node_acl()
251 acl->dynamic_node_acl = 1; core_tpg_check_initiator_node_acl()
260 core_tpg_add_node_to_devs(acl, tpg, NULL); core_tpg_check_initiator_node_acl()
262 target_add_node_acl(acl); core_tpg_check_initiator_node_acl()
263 return acl; core_tpg_check_initiator_node_acl()
277 struct se_node_acl *acl; core_tpg_add_initiator_node_acl() local
280 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname); core_tpg_add_initiator_node_acl()
281 if (acl) { core_tpg_add_initiator_node_acl()
282 if (acl->dynamic_node_acl) { core_tpg_add_initiator_node_acl()
283 acl->dynamic_node_acl = 0; core_tpg_add_initiator_node_acl()
288 return acl; core_tpg_add_initiator_node_acl()
300 acl = target_alloc_node_acl(tpg, initiatorname); core_tpg_add_initiator_node_acl()
301 if (!acl) core_tpg_add_initiator_node_acl()
304 target_add_node_acl(acl); core_tpg_add_initiator_node_acl()
305 return acl; core_tpg_add_initiator_node_acl()
308 void core_tpg_del_initiator_node_acl(struct se_node_acl *acl) core_tpg_del_initiator_node_acl() argument
310 struct se_portal_group *tpg = acl->se_tpg; core_tpg_del_initiator_node_acl()
317 if (acl->dynamic_node_acl) { core_tpg_del_initiator_node_acl()
318 acl->dynamic_node_acl = 0; core_tpg_del_initiator_node_acl()
320 list_del(&acl->acl_list); core_tpg_del_initiator_node_acl()
324 spin_lock_irqsave(&acl->nacl_sess_lock, flags); core_tpg_del_initiator_node_acl()
325 acl->acl_stop = 1; core_tpg_del_initiator_node_acl()
327 list_for_each_entry_safe(sess, sess_tmp, &acl->acl_sess_list, core_tpg_del_initiator_node_acl()
335 spin_unlock_irqrestore(&acl->nacl_sess_lock, flags); core_tpg_del_initiator_node_acl()
346 target_put_nacl(acl); core_tpg_del_initiator_node_acl()
351 wait_for_completion(&acl->acl_free_comp); core_tpg_del_initiator_node_acl()
353 core_tpg_wait_for_nacl_pr_ref(acl); core_tpg_del_initiator_node_acl()
354 core_free_device_list_for_node(acl, tpg); core_tpg_del_initiator_node_acl()
358 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth, core_tpg_del_initiator_node_acl()
359 tpg->se_tpg_tfo->get_fabric_name(), acl->initiatorname); core_tpg_del_initiator_node_acl()
361 kfree(acl); core_tpg_del_initiator_node_acl()
375 struct se_node_acl *acl; core_tpg_set_initiator_node_queue_depth() local
380 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname); core_tpg_set_initiator_node_queue_depth()
381 if (!acl) { core_tpg_set_initiator_node_queue_depth()
389 if (acl->dynamic_node_acl) { core_tpg_set_initiator_node_queue_depth()
390 acl->dynamic_node_acl = 0; core_tpg_set_initiator_node_queue_depth()
397 if (sess->se_node_acl != acl) core_tpg_set_initiator_node_queue_depth()
411 acl->dynamic_node_acl = 1; core_tpg_set_initiator_node_queue_depth()
434 acl->queue_depth = queue_depth; core_tpg_set_initiator_node_queue_depth()
436 if (core_set_queue_depth_for_node(tpg, acl) < 0) { core_tpg_set_initiator_node_queue_depth()
449 acl->dynamic_node_acl = 1; core_tpg_set_initiator_node_queue_depth()
468 acl->dynamic_node_acl = 1; core_tpg_set_initiator_node_queue_depth()
483 struct se_node_acl *acl, core_tpg_set_initiator_node_tag()
490 acl->acl_tag[0] = '\0'; core_tpg_set_initiator_node_tag()
494 return snprintf(acl->acl_tag, MAX_ACL_TAG_SIZE, "%s", new_tag); core_tpg_set_initiator_node_tag()
107 core_tpg_add_node_to_devs( struct se_node_acl *acl, struct se_portal_group *tpg, struct se_lun *lun_orig) core_tpg_add_node_to_devs() argument
164 core_set_queue_depth_for_node( struct se_portal_group *tpg, struct se_node_acl *acl) core_set_queue_depth_for_node() argument
481 core_tpg_set_initiator_node_tag( struct se_portal_group *tpg, struct se_node_acl *acl, const char *new_tag) core_tpg_set_initiator_node_tag() argument
|
| H A D | target_core_internal.h | 126 void core_tpg_del_initiator_node_acl(struct se_node_acl *acl);
|
| H A D | target_core_device.c | 575 struct se_node_acl *acl; core_dev_add_lun() local
578 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) { core_dev_add_lun()
579 if (acl->dynamic_node_acl && core_dev_add_lun()
582 core_tpg_add_node_to_devs(acl, tpg, lun); core_dev_add_lun()
|
| /linux-4.4.14/fs/nfs_common/ |
| H A D | nfsacl.c | 36 struct posix_acl *acl; member in struct:nfsacl_encode_desc
43 struct posix_acl acl; member in struct:nfsacl_simple_acl
55 &nfsacl_desc->acl->a_entries[nfsacl_desc->count++]; xdr_nfsace_encode()
85 * @acl: posix_acl to encode
92 struct posix_acl *acl, int encode_entries, int typeflag) nfsacl_encode()
94 int entries = (acl && acl->a_count) ? max_t(int, acl->a_count, 4) : 0; nfsacl_encode()
101 .acl = acl, nfsacl_encode()
112 if (encode_entries && acl && acl->a_count == 3) { nfsacl_encode()
113 struct posix_acl *acl2 = &aclbuf.acl; nfsacl_encode()
123 acl2->a_entries[0] = acl->a_entries[0]; /* ACL_USER_OBJ */ nfsacl_encode()
124 acl2->a_entries[1] = acl->a_entries[1]; /* ACL_GROUP_OBJ */ nfsacl_encode()
125 acl2->a_entries[2] = acl->a_entries[1]; /* ACL_MASK */ nfsacl_encode()
127 acl2->a_entries[3] = acl->a_entries[2]; /* ACL_OTHER */ nfsacl_encode()
128 nfsacl_desc.acl = acl2; nfsacl_encode()
141 struct posix_acl *acl; member in struct:nfsacl_decode_desc
153 if (!nfsacl_desc->acl) { xdr_nfsace_decode()
156 nfsacl_desc->acl = posix_acl_alloc(desc->array_len, GFP_KERNEL); xdr_nfsace_decode()
157 if (!nfsacl_desc->acl) xdr_nfsace_decode()
162 entry = &nfsacl_desc->acl->a_entries[nfsacl_desc->count++]; xdr_nfsace_decode()
218 posix_acl_from_nfsacl(struct posix_acl *acl) posix_acl_from_nfsacl() argument
223 if (!acl) posix_acl_from_nfsacl()
226 sort(acl->a_entries, acl->a_count, sizeof(struct posix_acl_entry), posix_acl_from_nfsacl()
230 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
244 if (acl->a_count == 4 && group_obj && mask &&
247 memmove(mask, mask+1, (3 - (mask - acl->a_entries)) *
249 acl->a_count = 3;
285 posix_acl_from_nfsacl(nfsacl_desc.acl) != 0) { nfsacl_decode()
286 posix_acl_release(nfsacl_desc.acl); nfsacl_decode()
289 *pacl = nfsacl_desc.acl; nfsacl_decode()
91 nfsacl_encode(struct xdr_buf *buf, unsigned int base, struct inode *inode, struct posix_acl *acl, int encode_entries, int typeflag) nfsacl_encode() argument
|
| /linux-4.4.14/include/linux/ |
| H A D | posix_acl.h | 54 #define FOREACH_ACL_ENTRY(pa, acl, pe) \
55 for(pa=(acl)->a_entries, pe=pa+(acl)->a_count; pa<pe; pa++)
62 posix_acl_dup(struct posix_acl *acl) posix_acl_dup() argument
64 if (acl) posix_acl_dup()
65 atomic_inc(&acl->a_refcount); posix_acl_dup()
66 return acl; posix_acl_dup()
73 posix_acl_release(struct posix_acl *acl) posix_acl_release() argument
75 if (acl && atomic_dec_and_test(&acl->a_refcount)) posix_acl_release()
76 kfree_rcu(acl, a_rcu); posix_acl_release()
105 void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl);
131 struct posix_acl **default_acl, struct posix_acl **acl) posix_acl_create()
133 *default_acl = *acl = NULL; posix_acl_create()
130 posix_acl_create(struct inode *inode, umode_t *mode, struct posix_acl **default_acl, struct posix_acl **acl) posix_acl_create() argument
|
| H A D | nfsacl.h | 36 struct posix_acl *acl, int encode_entries, int typeflag);
|
| H A D | posix_acl_xattr.h | 70 const struct posix_acl *acl, void *buffer, size_t size);
|
| H A D | nvme.h | 113 __u8 acl; member in struct:nvme_id_ctrl
|
| /linux-4.4.14/fs/xfs/ |
| H A D | xfs_acl.c | 45 struct posix_acl *acl; xfs_acl_from_disk() local
55 acl = posix_acl_alloc(count, GFP_KERNEL); xfs_acl_from_disk()
56 if (!acl) xfs_acl_from_disk()
60 acl_e = &acl->a_entries[i]; xfs_acl_from_disk()
88 return acl; xfs_acl_from_disk()
91 posix_acl_release(acl); xfs_acl_from_disk()
96 xfs_acl_to_disk(struct xfs_acl *aclp, const struct posix_acl *acl) xfs_acl_to_disk() argument
102 aclp->acl_cnt = cpu_to_be32(acl->a_count); xfs_acl_to_disk()
103 for (i = 0; i < acl->a_count; i++) { xfs_acl_to_disk()
105 acl_e = &acl->a_entries[i]; xfs_acl_to_disk()
128 struct posix_acl *acl = NULL; xfs_get_acl() local
166 acl = ERR_PTR(error); xfs_get_acl()
170 acl = xfs_acl_from_disk(xfs_acl, len, XFS_ACL_MAX_ENTRIES(ip->i_mount)); xfs_get_acl()
171 if (IS_ERR(acl)) xfs_get_acl()
175 set_cached_acl(inode, type, acl); xfs_get_acl()
178 return acl; xfs_get_acl()
182 __xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl) __xfs_set_acl() argument
194 return acl ? -EACCES : 0; __xfs_set_acl()
201 if (acl) { __xfs_set_acl()
209 xfs_acl_to_disk(xfs_acl, acl); __xfs_set_acl()
211 /* subtract away the unused acl entries */ __xfs_set_acl()
213 (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count); __xfs_set_acl()
233 set_cached_acl(inode, type, acl); __xfs_set_acl()
279 xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) xfs_set_acl() argument
283 if (!acl) xfs_set_acl()
287 if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) xfs_set_acl()
292 error = posix_acl_equiv_mode(acl, &mode); xfs_set_acl()
295 acl = NULL; xfs_set_acl()
307 return __xfs_set_acl(inode, type, acl); xfs_set_acl()
|
| H A D | xfs_acl.h | 26 extern int xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
|
| H A D | xfs_iops.c | 136 struct posix_acl *default_acl, *acl; xfs_generic_create() local
152 error = posix_acl_create(dir, &mode, &default_acl, &acl); xfs_generic_create()
177 if (acl) { xfs_generic_create()
178 error = xfs_set_acl(inode, acl, ACL_TYPE_ACCESS); xfs_generic_create()
194 if (acl) xfs_generic_create()
195 posix_acl_release(acl); xfs_generic_create()
|
| /linux-4.4.14/fs/nfs/ |
| H A D | nfs3_fs.h | 14 extern int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type);
15 extern int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
20 static inline int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl, nfs3_proc_setacls() argument
|
| H A D | nfs3acl.c | 40 * Only get the access acl when explicitly requested: We don't nfs3_get_acl()
42 * it. Applications which request the access acl first are not nfs3_get_acl()
117 static int __nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl, __nfs3_proc_setacls() argument
126 .acl_access = acl, __nfs3_proc_setacls()
135 if (acl == NULL && (!S_ISDIR(inode->i_mode) || dfacl == NULL)) __nfs3_proc_setacls()
145 if (acl != NULL && acl->a_count > NFS_ACL_MAX_ENTRIES) __nfs3_proc_setacls()
152 args.len = nfsacl_size(acl, dfacl); __nfs3_proc_setacls()
154 args.len = nfsacl_size(acl, NULL); __nfs3_proc_setacls()
184 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); __nfs3_proc_setacls()
205 int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl, nfs3_proc_setacls() argument
209 ret = __nfs3_proc_setacls(inode, acl, dfacl); nfs3_proc_setacls()
214 int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type) nfs3_set_acl() argument
228 dfacl = acl; nfs3_set_acl()
229 alloc = acl = get_acl(inode, ACL_TYPE_ACCESS); nfs3_set_acl()
236 if (acl == NULL) { nfs3_set_acl()
237 alloc = acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL); nfs3_set_acl()
241 status = __nfs3_proc_setacls(inode, acl, dfacl); nfs3_set_acl()
259 struct posix_acl *acl; nfs3_list_one_acl() local
262 acl = get_acl(inode, type); nfs3_list_one_acl()
263 if (IS_ERR_OR_NULL(acl)) nfs3_list_one_acl()
266 posix_acl_release(acl); nfs3_list_one_acl()
|
| H A D | nfs3proc.c | 322 struct posix_acl *default_acl, *acl; nfs3_proc_create() local
345 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); nfs3_proc_create()
395 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); nfs3_proc_create()
398 posix_acl_release(acl); nfs3_proc_create()
549 struct posix_acl *default_acl, *acl; nfs3_proc_mkdir() local
559 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); nfs3_proc_mkdir()
573 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); nfs3_proc_mkdir()
576 posix_acl_release(acl); nfs3_proc_mkdir()
674 struct posix_acl *default_acl, *acl; nfs3_proc_mknod() local
685 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); nfs3_proc_mknod()
718 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); nfs3_proc_mknod()
721 posix_acl_release(acl); nfs3_proc_mknod()
|
| H A D | nfs3xdr.c | 2349 struct posix_acl **acl; decode_getacl3resok() local
2366 acl = NULL; decode_getacl3resok()
2368 acl = &result->acl_access; decode_getacl3resok()
2372 error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl); decode_getacl3resok()
2376 acl = NULL; decode_getacl3resok()
2378 acl = &result->acl_default; decode_getacl3resok()
2382 error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl); decode_getacl3resok()
|
| H A D | nfs4proc.c | 4640 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl) nfs4_set_cached_acl() argument
4646 nfsi->nfs4_acl = acl; nfs4_set_cached_acl()
4658 struct nfs4_cached_acl *acl; nfs4_read_cached_acl() local
4662 acl = nfsi->nfs4_acl; nfs4_read_cached_acl()
4663 if (acl == NULL) nfs4_read_cached_acl()
4667 if (acl->cached == 0) nfs4_read_cached_acl()
4670 if (acl->len > buflen) nfs4_read_cached_acl()
4672 memcpy(buf, acl->data, acl->len); nfs4_read_cached_acl()
4674 ret = acl->len; nfs4_read_cached_acl()
4682 struct nfs4_cached_acl *acl; nfs4_write_cached_acl() local
4683 size_t buflen = sizeof(*acl) + acl_len; nfs4_write_cached_acl()
4686 acl = kmalloc(buflen, GFP_KERNEL); nfs4_write_cached_acl()
4687 if (acl == NULL) nfs4_write_cached_acl()
4689 acl->cached = 1; nfs4_write_cached_acl()
4690 _copy_from_pages(acl->data, pages, pgbase, acl_len); nfs4_write_cached_acl()
4692 acl = kmalloc(sizeof(*acl), GFP_KERNEL); nfs4_write_cached_acl()
4693 if (acl == NULL) nfs4_write_cached_acl()
4695 acl->cached = 0; nfs4_write_cached_acl()
4697 acl->len = acl_len; nfs4_write_cached_acl()
4699 nfs4_set_cached_acl(inode, acl); nfs4_write_cached_acl()
4704 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
4732 * let's be prepared for a page of acl data. */ __nfs4_get_acl_uncached()
4760 /* Did the user only issue a request for the acl length? */ __nfs4_get_acl_uncached()
4814 * but no cached acl data, just the acl length */ nfs4_proc_get_acl()
|
| H A D | super.c | 142 { Opt_acl, "acl" },
843 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask); nfs_show_stats()
|
| H A D | nfs4xdr.c | 5317 * are stored with the acl data to handle the problem of decode_getacl()
5326 dprintk("NFS: acl reply: attrlen %u > page_len %u\n", decode_getacl()
|
| /linux-4.4.14/drivers/staging/lustre/lustre/obdclass/ |
| H A D | Makefile | 9 cl_page.o cl_lock.o cl_io.o lu_ref.o acl.o lprocfs_counters.o
|
| H A D | acl.c | 36 * lustre/obdclass/acl.c
|
| H A D | lprocfs_status.c | 57 "acl",
|
| H A D | obd_mount.c | 912 user_xattr, acl */ lmd_parse()
|
| /linux-4.4.14/drivers/target/tcm_fc/ |
| H A D | tfc_conf.c | 135 struct ft_node_acl *acl = container_of(se_nacl, ft_nacl_port_name_show() local
138 return ft_wwn_show(&acl->node_auth.port_name, page); ft_nacl_port_name_show()
145 struct ft_node_acl *acl = container_of(se_nacl, ft_nacl_port_name_store() local
148 return ft_wwn_store(&acl->node_auth.port_name, page, count); ft_nacl_port_name_store()
155 struct ft_node_acl *acl = container_of(se_nacl, ft_nacl_node_name_show() local
158 return ft_wwn_show(&acl->node_auth.node_name, page); ft_nacl_node_name_show()
165 struct ft_node_acl *acl = container_of(se_nacl, ft_nacl_node_name_store() local
168 return ft_wwn_store(&acl->node_auth.node_name, page, count); ft_nacl_node_name_store()
190 struct ft_node_acl *acl = ft_init_nodeacl() local
197 acl->node_auth.port_name = wwpn; ft_init_nodeacl()
204 struct ft_node_acl *acl; ft_acl_get() local
210 acl = container_of(se_acl, struct ft_node_acl, se_node_acl); ft_acl_get()
211 pr_debug("acl %p port_name %llx\n", ft_acl_get()
212 acl, (unsigned long long)acl->node_auth.port_name); ft_acl_get()
213 if (acl->node_auth.port_name == rdata->ids.port_name || ft_acl_get()
214 acl->node_auth.node_name == rdata->ids.node_name) { ft_acl_get()
215 pr_debug("acl %p port_name %llx matched\n", acl, ft_acl_get()
217 found = acl; ft_acl_get()
|
| H A D | tfc_sess.c | 194 struct ft_node_acl *acl) ft_sess_create()
215 sess->se_sess->se_node_acl = &acl->se_node_acl; ft_sess_create()
224 transport_register_session(&tport->tpg->se_tpg, &acl->se_node_acl, ft_sess_create()
346 struct ft_node_acl *acl; ft_prli_locked() local
353 acl = ft_acl_get(tport->tpg, rdata); ft_prli_locked()
354 if (!acl) ft_prli_locked()
378 sess = ft_sess_create(tport, rdata->ids.port_id, acl); ft_prli_locked()
193 ft_sess_create(struct ft_tport *tport, u32 port_id, struct ft_node_acl *acl) ft_sess_create() argument
|
| /linux-4.4.14/fs/nfsd/ |
| H A D | nfs2acl.c | 33 struct posix_acl *acl; nfsacld_proc_getacl() local
38 dprintk("nfsd: GETACL(2acl) %s\n", SVCFH_fmt(&argp->fh)); nfsacld_proc_getacl()
56 acl = get_acl(inode, ACL_TYPE_ACCESS); nfsacld_proc_getacl()
57 if (acl == NULL) { nfsacld_proc_getacl()
59 acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL); nfsacld_proc_getacl()
61 if (IS_ERR(acl)) { nfsacld_proc_getacl()
62 nfserr = nfserrno(PTR_ERR(acl)); nfsacld_proc_getacl()
65 resp->acl_access = acl; nfsacld_proc_getacl()
70 acl = get_acl(inode, ACL_TYPE_DEFAULT); nfsacld_proc_getacl()
71 if (IS_ERR(acl)) { nfsacld_proc_getacl()
72 nfserr = nfserrno(PTR_ERR(acl)); nfsacld_proc_getacl()
75 resp->acl_default = acl; nfsacld_proc_getacl()
99 dprintk("nfsd: SETACL(2acl) %s\n", SVCFH_fmt(&argp->fh)); nfsacld_proc_setacl()
166 dprintk("nfsd: ACCESS(2acl) %s 0x%x\n", nfsacld_proc_access()
|
| H A D | nfs4acl.c | 43 #include "acl.h"
130 struct nfs4_acl **acl) nfsd4_get_nfs4_acl()
160 *acl = kmalloc(nfs4_acl_bytes(size), GFP_KERNEL); nfsd4_get_nfs4_acl()
161 if (*acl == NULL) { nfsd4_get_nfs4_acl()
165 (*acl)->naces = 0; nfsd4_get_nfs4_acl()
167 _posix_to_nfsv4_one(pacl, *acl, flags & ~NFS4_ACL_TYPE_DEFAULT); nfsd4_get_nfs4_acl()
170 _posix_to_nfsv4_one(dpacl, *acl, flags | NFS4_ACL_TYPE_DEFAULT); nfsd4_get_nfs4_acl()
189 summarize_posix_acl(struct posix_acl *acl, struct posix_acl_summary *pas) summarize_posix_acl() argument
201 pe = acl->a_entries + acl->a_count; summarize_posix_acl()
203 FOREACH_ACL_ENTRY(pa, acl, pe) { FOREACH_ACL_ENTRY()
231 /* We assume the acl has been verified with posix_acl_valid. */
233 _posix_to_nfsv4_one(struct posix_acl *pacl, struct nfs4_acl *acl, _posix_to_nfsv4_one() argument
247 ace = acl->aces + acl->naces; _posix_to_nfsv4_one()
262 acl->naces++; _posix_to_nfsv4_one()
270 acl->naces++; _posix_to_nfsv4_one()
283 acl->naces++; _posix_to_nfsv4_one()
292 acl->naces++; _posix_to_nfsv4_one()
308 acl->naces++; _posix_to_nfsv4_one()
319 acl->naces++; _posix_to_nfsv4_one()
334 acl->naces++; _posix_to_nfsv4_one()
348 acl->naces++; _posix_to_nfsv4_one()
359 acl->naces++; _posix_to_nfsv4_one()
379 * expecting acl's to be long enough to justify anything more. */ sort_pacl_range()
462 * In the worst case, each individual acl could be for a distinct init_state()
692 static int nfs4_acl_nfsv4_to_posix(struct nfs4_acl *acl, nfs4_acl_nfsv4_to_posix() argument
700 ret = init_state(&effective_acl_state, acl->naces); nfs4_acl_nfsv4_to_posix()
703 ret = init_state(&default_acl_state, acl->naces); nfs4_acl_nfsv4_to_posix()
707 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { nfs4_acl_nfsv4_to_posix()
756 struct nfs4_acl *acl) nfsd4_set_nfs4_acl()
779 host_error = nfs4_acl_nfsv4_to_posix(acl, &pacl, &dpacl, flags); nfsd4_set_nfs4_acl()
824 * return the size of the struct nfs4_acl required to represent an acl
129 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry, struct nfs4_acl **acl) nfsd4_get_nfs4_acl() argument
755 nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_acl *acl) nfsd4_set_nfs4_acl() argument
|
| H A D | nfs3acl.c | 32 struct posix_acl *acl; nfsd3_proc_getacl() local
49 acl = get_acl(inode, ACL_TYPE_ACCESS); nfsd3_proc_getacl()
50 if (acl == NULL) { nfsd3_proc_getacl()
52 acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL); nfsd3_proc_getacl()
54 if (IS_ERR(acl)) { nfsd3_proc_getacl()
55 nfserr = nfserrno(PTR_ERR(acl)); nfsd3_proc_getacl()
58 resp->acl_access = acl; nfsd3_proc_getacl()
63 acl = get_acl(inode, ACL_TYPE_DEFAULT); nfsd3_proc_getacl()
64 if (IS_ERR(acl)) { nfsd3_proc_getacl()
65 nfserr = nfserrno(PTR_ERR(acl)); nfsd3_proc_getacl()
68 resp->acl_default = acl; nfsd3_proc_getacl()
|
| H A D | acl.h | 55 struct nfs4_acl **acl);
57 struct nfs4_acl *acl);
|
| H A D | nfs4xdr.c | 45 #include "acl.h"
287 struct iattr *iattr, struct nfs4_acl **acl, nfsd4_decode_fattr()
318 *acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(nace)); nfsd4_decode_fattr()
319 if (*acl == NULL) nfsd4_decode_fattr()
322 (*acl)->naces = nace; nfsd4_decode_fattr()
323 for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) { nfsd4_decode_fattr()
346 *acl = NULL; nfsd4_decode_fattr()
2290 struct nfs4_acl *acl = NULL; nfsd4_encode_fattr() local
2336 err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl); nfsd4_encode_fattr()
2493 if (acl == NULL) { nfsd4_encode_fattr()
2504 *p++ = cpu_to_be32(acl->naces); nfsd4_encode_fattr()
2506 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { nfsd4_encode_fattr()
2779 kfree(acl); nfsd4_encode_fattr()
286 nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval, struct iattr *iattr, struct nfs4_acl **acl, struct xdr_netobj *label) nfsd4_decode_fattr() argument
|
| H A D | nfs4proc.c | 45 #include "acl.h"
158 * if error occurs when setting the acl, just clear the acl bit
163 struct nfs4_acl *acl, u32 *bmval) do_set_nfs4_acl()
167 status = nfsd4_set_nfs4_acl(rqstp, fhp, acl); do_set_nfs4_acl()
162 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_acl *acl, u32 *bmval) do_set_nfs4_acl() argument
|
| H A D | vfs.c | 39 #include "acl.h"
|
| /linux-4.4.14/security/tomoyo/ |
| H A D | gc.c | 50 head->r.acl == element || &head->w.domain->list == element) tomoyo_struct_used_by_io_buffer()
152 struct tomoyo_acl_info *acl = tomoyo_del_acl() local
153 container_of(element, typeof(*acl), list); tomoyo_del_acl()
154 tomoyo_put_condition(acl->cond); tomoyo_del_acl()
155 switch (acl->type) { tomoyo_del_acl()
159 = container_of(acl, typeof(*entry), head); tomoyo_del_acl()
166 = container_of(acl, typeof(*entry), head); tomoyo_del_acl()
174 = container_of(acl, typeof(*entry), head); tomoyo_del_acl()
182 = container_of(acl, typeof(*entry), head); tomoyo_del_acl()
192 = container_of(acl, typeof(*entry), head); tomoyo_del_acl()
202 container_of(acl, typeof(*entry), head); tomoyo_del_acl()
210 container_of(acl, typeof(*entry), head); tomoyo_del_acl()
219 container_of(acl, typeof(*entry), head); tomoyo_del_acl()
227 container_of(acl, typeof(*entry), head); tomoyo_del_acl()
247 struct tomoyo_acl_info *acl; tomoyo_del_domain() local
254 list_for_each_entry_safe(acl, tmp, &domain->acl_info_list, list) { tomoyo_del_domain()
255 tomoyo_del_acl(&acl->list); tomoyo_del_domain()
256 tomoyo_memory_free(acl); tomoyo_del_domain()
390 * Don't kfree() until "struct tomoyo_io_buffer"->r.{domain,group,acl} tomoyo_try_to_gc()
495 struct tomoyo_acl_info *acl; tomoyo_collect_acl() local
497 list_for_each_entry_safe(acl, tmp, list, list) { list_for_each_entry_safe()
498 if (!acl->is_deleted) list_for_each_entry_safe()
500 acl->is_deleted = TOMOYO_GC_IN_PROGRESS; list_for_each_entry_safe()
501 tomoyo_try_to_gc(TOMOYO_ID_ACL, &acl->list); list_for_each_entry_safe()
|
| H A D | mount.c | 48 const struct tomoyo_mount_acl *acl = tomoyo_check_mount_acl() local
49 container_of(ptr, typeof(*acl), head); tomoyo_check_mount_acl()
51 &acl->flags) && tomoyo_check_mount_acl()
53 &acl->fs_type) && tomoyo_check_mount_acl()
55 &acl->dir_name) && tomoyo_check_mount_acl()
58 &acl->dev_name)); tomoyo_check_mount_acl()
|
| H A D | environ.c | 20 const struct tomoyo_env_acl *acl = tomoyo_check_env_acl() local
21 container_of(ptr, typeof(*acl), head); tomoyo_check_env_acl()
23 return tomoyo_path_matches_pattern(r->param.environ.name, acl->env); tomoyo_check_env_acl()
|
| H A D | file.c | 253 const struct tomoyo_path_acl *acl = container_of(ptr, typeof(*acl), tomoyo_check_path_acl() local
255 if (acl->perm & (1 << r->param.path.operation)) { tomoyo_check_path_acl()
258 &acl->name); tomoyo_check_path_acl()
275 const struct tomoyo_path_number_acl *acl = tomoyo_check_path_number_acl() local
276 container_of(ptr, typeof(*acl), head); tomoyo_check_path_number_acl()
277 return (acl->perm & (1 << r->param.path_number.operation)) && tomoyo_check_path_number_acl()
279 &acl->number) && tomoyo_check_path_number_acl()
281 &acl->name); tomoyo_check_path_number_acl()
295 const struct tomoyo_path2_acl *acl = tomoyo_check_path2_acl() local
296 container_of(ptr, typeof(*acl), head); tomoyo_check_path2_acl()
297 return (acl->perm & (1 << r->param.path2.operation)) && tomoyo_check_path2_acl()
298 tomoyo_compare_name_union(r->param.path2.filename1, &acl->name1) tomoyo_check_path2_acl()
300 &acl->name2); tomoyo_check_path2_acl()
314 const struct tomoyo_mkdev_acl *acl = tomoyo_check_mkdev_acl() local
315 container_of(ptr, typeof(*acl), head); tomoyo_check_mkdev_acl()
316 return (acl->perm & (1 << r->param.mkdev.operation)) && tomoyo_check_mkdev_acl()
318 &acl->mode) && tomoyo_check_mkdev_acl()
320 &acl->major) && tomoyo_check_mkdev_acl()
322 &acl->minor) && tomoyo_check_mkdev_acl()
324 &acl->name); tomoyo_check_mkdev_acl()
|
| H A D | network.c | 421 const struct tomoyo_inet_acl *acl = tomoyo_check_inet_acl() local
422 container_of(ptr, typeof(*acl), head); tomoyo_check_inet_acl()
425 if (!(acl->perm & (1 << r->param.inet_network.operation)) || tomoyo_check_inet_acl()
427 &acl->port)) tomoyo_check_inet_acl()
429 if (acl->address.group) tomoyo_check_inet_acl()
432 r->param.inet_network.address, acl->address.group); tomoyo_check_inet_acl()
433 return acl->address.is_ipv6 == r->param.inet_network.is_ipv6 && tomoyo_check_inet_acl()
434 memcmp(&acl->address.ip[0], tomoyo_check_inet_acl()
437 &acl->address.ip[1], size) <= 0; tomoyo_check_inet_acl()
451 const struct tomoyo_unix_acl *acl = tomoyo_check_unix_acl() local
452 container_of(ptr, typeof(*acl), head); tomoyo_check_unix_acl()
454 return (acl->perm & (1 << r->param.unix_network.operation)) && tomoyo_check_unix_acl()
456 &acl->name); tomoyo_check_unix_acl()
|
| H A D | common.c | 896 list_for_each_cookie(head->r.acl, &tomoyo_kernel_namespace. tomoyo_read_manager()
899 list_entry(head->r.acl, typeof(*ptr), head.list); tomoyo_read_manager()
1356 * @acl: Pointer to an ACL entry.
1361 struct tomoyo_acl_info *acl) tomoyo_print_entry()
1363 const u8 acl_type = acl->type; tomoyo_print_entry()
1369 if (acl->is_deleted) tomoyo_print_entry()
1375 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1396 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1404 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1424 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1444 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1466 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1498 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1520 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1528 container_of(acl, typeof(*ptr), head); tomoyo_print_entry()
1533 if (acl->cond) { tomoyo_print_entry()
1539 if (!tomoyo_print_condition(head, acl->cond)) tomoyo_print_entry()
1561 list_for_each_cookie(head->r.acl, list) { tomoyo_read_domain2()
1563 list_entry(head->r.acl, typeof(*ptr), list); tomoyo_read_domain2()
1567 head->r.acl = NULL; tomoyo_read_domain2()
1750 list_for_each_cookie(head->r.acl, &group->member_list) { tomoyo_read_group()
1752 list_entry(head->r.acl, typeof(*ptr), list); tomoyo_read_group()
1782 head->r.acl = NULL; tomoyo_read_group()
1803 list_for_each_cookie(head->r.acl, list) { tomoyo_read_policy()
1804 struct tomoyo_acl_head *acl = tomoyo_read_policy() local
1805 container_of(head->r.acl, typeof(*acl), list); tomoyo_read_policy()
1806 if (acl->is_deleted) tomoyo_read_policy()
1814 container_of(acl, typeof(*ptr), head); tomoyo_read_policy()
1829 container_of(acl, typeof(*ptr), head); tomoyo_read_policy()
1844 head->r.acl = NULL; tomoyo_read_policy()
1360 tomoyo_print_entry(struct tomoyo_io_buffer *head, struct tomoyo_acl_info *acl) tomoyo_print_entry() argument
|
| H A D | securityfs_if.c | 21 const struct tomoyo_task_acl *acl = container_of(ptr, typeof(*acl), tomoyo_check_task_acl() local
23 return !tomoyo_pathcmp(r->param.task.domainname, acl->domainname); tomoyo_check_task_acl()
|
| H A D | common.h | 800 struct list_head *acl; member in struct:tomoyo_io_buffer::__anon15191
|
| /linux-4.4.14/drivers/staging/lustre/lustre/llite/ |
| H A D | xattr.c | 117 ext_acl_xattr_header *acl = NULL; ll_setxattr_common() local
163 acl = lustre_acl_xattr_merge2ext( ll_setxattr_common()
166 if (IS_ERR(acl)) { ll_setxattr_common()
168 return PTR_ERR(acl); ll_setxattr_common()
171 le32_to_cpu(acl->a_count), \ ll_setxattr_common()
173 pv = (const char *)acl; ll_setxattr_common()
197 if (acl != NULL) ll_setxattr_common()
198 lustre_ext_acl_xattr_free(acl); ll_setxattr_common()
333 /* posix acl is under protection of LOOKUP lock. when calling to this, ll_getxattr_common()
340 struct posix_acl *acl; ll_getxattr_common() local
343 acl = posix_acl_dup(lli->lli_posix_acl); ll_getxattr_common()
346 if (!acl) ll_getxattr_common()
349 rc = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); ll_getxattr_common()
350 posix_acl_release(acl); ll_getxattr_common()
422 ext_acl_xattr_header *acl; ll_getxattr_common() local
424 acl = lustre_posix_acl_xattr_2ext( ll_getxattr_common()
426 if (IS_ERR(acl)) { ll_getxattr_common()
427 rc = PTR_ERR(acl); ll_getxattr_common()
432 xattr_type, acl); ll_getxattr_common()
434 lustre_ext_acl_xattr_free(acl); ll_getxattr_common()
|
| H A D | llite_internal.h | 418 "acl", \
441 int rce_ops; /* acl operation type */
|
| H A D | namei.c | 528 /* enforce umask if acl disabled or MDS doesn't support umask */ ll_lookup_it()
|
| H A D | file.c | 3056 struct posix_acl *acl = NULL; ll_get_acl() local
3060 acl = posix_acl_dup(lli->lli_posix_acl); ll_get_acl()
3063 return acl; ll_get_acl()
|
| H A D | llite_lib.c | 316 LCONSOLE_INFO("client wants to enable acl, but mdt not!\n"); client_common_fill_super()
|
| /linux-4.4.14/fs/coda/ |
| H A D | cache.c | 29 /* replace or extend an acl cache hit */ coda_cache_enter()
44 /* remove cached acl from an inode */ coda_cache_clear_inode()
53 /* remove all acl caches */ coda_cache_clear_all()
60 /* check if the mask has been matched against the acl already */ coda_cache_check()
|
| /linux-4.4.14/drivers/staging/rdma/ehca/ |
| H A D | ehca_mrmw.h | 54 int acl,
82 int acl,
94 int acl,
|
| H A D | ehca_mrmw.c | 530 new_acl = e_mr->acl; ehca_rereg_phys_mr()
628 ehca_mrmw_reverse_map_acl(&hipzout.acl, &mr_attr->mr_access_flags); ehca_query_mr()
904 e_fmr->acl, e_pd, &pginfo, &tmp_lkey, &tmp_rkey); ehca_map_phys_fmr()
1025 int acl, ehca_reg_mr()
1037 ehca_mrmw_map_acl(acl, &hipz_acl); ehca_reg_mr()
1070 e_mr->acl = acl; ehca_reg_mr()
1079 "iova_start=%p size=%llx acl=%x e_pd=%p lkey=%x " ehca_reg_mr()
1081 h_ret, shca, e_mr, iova_start, size, acl, e_pd, ehca_reg_mr()
1090 "iova_start=%p size=%llx acl=%x e_pd=%p pginfo=%p " ehca_reg_mr()
1092 ret, shca, e_mr, iova_start, size, acl, e_pd, pginfo, ehca_reg_mr()
1201 u32 acl, ehca_rereg_mr_rereg1()
1215 ehca_mrmw_map_acl(acl, &hipz_acl); ehca_rereg_mr_rereg1()
1270 e_mr->acl = acl; ehca_rereg_mr_rereg1()
1292 int acl, ehca_rereg_mr()
1324 acl, e_pd, pginfo, lkey, rkey); ehca_rereg_mr()
1360 ret = ehca_reg_mr(shca, e_mr, iova_start, size, acl, ehca_rereg_mr()
1373 "iova_start=%p size=%llx acl=%x e_pd=%p pginfo=%p " ehca_rereg_mr()
1376 acl, e_pd, pginfo, pginfo->num_kpages, *lkey, *rkey, ehca_rereg_mr()
1447 e_fmr->acl = save_fmr.acl; ehca_unmap_one_fmr()
1453 e_fmr->acl, e_pd, &pginfo, &tmp_lkey, ehca_unmap_one_fmr()
1475 int acl, ehca_reg_smr()
1485 ehca_mrmw_map_acl(acl, &hipz_acl); ehca_reg_smr()
1493 "shca=%p e_origmr=%p e_newmr=%p iova_start=%p acl=%x " ehca_reg_smr()
1495 h_ret, shca, e_origmr, e_newmr, iova_start, acl, e_pd, ehca_reg_smr()
1508 e_newmr->acl = acl; ehca_reg_smr()
1517 "e_newmr=%p iova_start=%p acl=%x e_pd=%p", ehca_reg_smr()
1518 ret, shca, e_origmr, e_newmr, iova_start, acl, e_pd); ehca_reg_smr()
1690 int acl, ehca_reg_maxmr()
1700 ehca_mrmw_map_acl(acl, &hipz_acl); ehca_reg_maxmr()
1720 e_newmr->acl = acl; ehca_reg_maxmr()
2222 mr->acl = 0; ehca_mr_deletenew()
1021 ehca_reg_mr(struct ehca_shca *shca, struct ehca_mr *e_mr, u64 *iova_start, u64 size, int acl, struct ehca_pd *e_pd, struct ehca_mr_pginfo *pginfo, u32 *lkey, u32 *rkey, enum ehca_reg_type reg_type) ehca_reg_mr() argument
1197 ehca_rereg_mr_rereg1(struct ehca_shca *shca, struct ehca_mr *e_mr, u64 *iova_start, u64 size, u32 acl, struct ehca_pd *e_pd, struct ehca_mr_pginfo *pginfo, u32 *lkey, u32 *rkey) ehca_rereg_mr_rereg1() argument
1288 ehca_rereg_mr(struct ehca_shca *shca, struct ehca_mr *e_mr, u64 *iova_start, u64 size, int acl, struct ehca_pd *e_pd, struct ehca_mr_pginfo *pginfo, u32 *lkey, u32 *rkey) ehca_rereg_mr() argument
1471 ehca_reg_smr(struct ehca_shca *shca, struct ehca_mr *e_origmr, struct ehca_mr *e_newmr, u64 *iova_start, int acl, struct ehca_pd *e_pd, u32 *lkey, u32 *rkey) ehca_reg_smr() argument
1687 ehca_reg_maxmr(struct ehca_shca *shca, struct ehca_mr *e_newmr, u64 *iova_start, int acl, struct ehca_pd *e_pd, u32 *lkey, u32 *rkey) ehca_reg_maxmr() argument
|
| H A D | ehca_classes.h | 278 int acl; /* ACL (stored here for usage in reregister) */ member in struct:ehca_mr
343 u32 acl; member in struct:ehca_mr_hipzout_parms
|
| H A D | hcp_if.c | 809 outparms->acl = outs[4] >> 32; hipz_h_query_mr()
|
| /linux-4.4.14/net/bluetooth/ |
| H A D | hci_conn.c | 590 struct hci_conn *acl = conn->link; hci_conn_del() local
591 if (acl) { hci_conn_del()
592 acl->link = NULL; hci_conn_del()
593 hci_conn_drop(acl); hci_conn_del()
1076 struct hci_conn *acl; hci_connect_acl() local
1085 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst); hci_connect_acl()
1086 if (!acl) { hci_connect_acl()
1087 acl = hci_conn_add(hdev, ACL_LINK, dst, HCI_ROLE_MASTER); hci_connect_acl()
1088 if (!acl) hci_connect_acl()
1092 hci_conn_hold(acl); hci_connect_acl()
1094 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) { hci_connect_acl()
1095 acl->sec_level = BT_SECURITY_LOW; hci_connect_acl()
1096 acl->pending_sec_level = sec_level; hci_connect_acl()
1097 acl->auth_type = auth_type; hci_connect_acl()
1098 hci_acl_create_connection(acl); hci_connect_acl()
1101 return acl; hci_connect_acl()
1107 struct hci_conn *acl; hci_connect_sco() local
1110 acl = hci_connect_acl(hdev, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING); hci_connect_sco()
1111 if (IS_ERR(acl)) hci_connect_sco()
1112 return acl; hci_connect_sco()
1118 hci_conn_drop(acl); hci_connect_sco()
1123 acl->link = sco; hci_connect_sco()
1124 sco->link = acl; hci_connect_sco()
1130 if (acl->state == BT_CONNECTED && hci_connect_sco()
1132 set_bit(HCI_CONN_POWER_SAVE, &acl->flags); hci_connect_sco()
1133 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON); hci_connect_sco()
1135 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) { hci_connect_sco()
1137 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags); hci_connect_sco()
1141 hci_sco_setup(acl, 0x00); hci_connect_sco()
|
| H A D | hci_event.c | 683 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, hdev->acl_mtu, hci_cc_read_buffer_size()
1498 struct hci_conn *acl, *sco; hci_cs_add_sco() local
1516 acl = hci_conn_hash_lookup_handle(hdev, handle); hci_cs_add_sco()
1517 if (acl) { hci_cs_add_sco()
1518 sco = acl->link; hci_cs_add_sco()
1790 struct hci_conn *acl, *sco; hci_cs_setup_sync_conn() local
1808 acl = hci_conn_hash_lookup_handle(hdev, handle); hci_cs_setup_sync_conn()
1809 if (acl) { hci_cs_setup_sync_conn()
1810 sco = acl->link; hci_cs_setup_sync_conn()
|
| H A D | hci_core.c | 4255 BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, hci_tx_work()
|
| /linux-4.4.14/drivers/net/wireless/prism54/ |
| H A D | isl_ioctl.c | 350 if ((*uwrq == IW_MODE_MASTER) && (priv->acl.policy != MAC_POLICY_OPEN)) prism54_set_mode()
1783 prism54_acl_init(struct islpci_acl *acl) prism54_acl_init() argument
1785 mutex_init(&acl->lock); prism54_acl_init()
1786 INIT_LIST_HEAD(&acl->mac_list); prism54_acl_init()
1787 acl->size = 0; prism54_acl_init()
1788 acl->policy = MAC_POLICY_OPEN; prism54_acl_init()
1792 prism54_clear_mac(struct islpci_acl *acl) prism54_clear_mac() argument
1797 mutex_lock(&acl->lock); prism54_clear_mac()
1799 if (acl->size == 0) { prism54_clear_mac()
1800 mutex_unlock(&acl->lock); prism54_clear_mac()
1804 for (ptr = acl->mac_list.next, next = ptr->next; prism54_clear_mac()
1805 ptr != &acl->mac_list; ptr = next, next = ptr->next) { prism54_clear_mac()
1810 acl->size = 0; prism54_clear_mac()
1811 mutex_unlock(&acl->lock); prism54_clear_mac()
1815 prism54_acl_clean(struct islpci_acl *acl) prism54_acl_clean() argument
1817 prism54_clear_mac(acl); prism54_acl_clean()
1825 struct islpci_acl *acl = &priv->acl; prism54_add_mac() local
1838 if (mutex_lock_interruptible(&acl->lock)) { prism54_add_mac()
1842 list_add_tail(&entry->_list, &acl->mac_list); prism54_add_mac()
1843 acl->size++; prism54_add_mac()
1844 mutex_unlock(&acl->lock); prism54_add_mac()
1854 struct islpci_acl *acl = &priv->acl; prism54_del_mac() local
1861 if (mutex_lock_interruptible(&acl->lock)) prism54_del_mac()
1863 list_for_each_entry(entry, &acl->mac_list, _list) { prism54_del_mac()
1866 acl->size--; prism54_del_mac()
1868 mutex_unlock(&acl->lock); prism54_del_mac()
1872 mutex_unlock(&acl->lock); prism54_del_mac()
1881 struct islpci_acl *acl = &priv->acl; prism54_get_mac() local
1887 if (mutex_lock_interruptible(&acl->lock)) prism54_get_mac()
1890 list_for_each_entry(entry, &acl->mac_list, _list) { prism54_get_mac()
1896 mutex_unlock(&acl->lock); prism54_get_mac()
1900 /* Setting policy also clears the MAC acl, even if we don't change the default
1909 struct islpci_acl *acl = &priv->acl; prism54_set_policy() local
1912 prism54_clear_mac(acl); prism54_set_policy()
1919 acl->policy = *uwrq; prism54_set_policy()
1923 (acl->policy != MAC_POLICY_OPEN)) prism54_set_policy()
1945 struct islpci_acl *acl = &priv->acl; prism54_get_policy() local
1947 *uwrq = acl->policy; prism54_get_policy()
1955 prism54_mac_accept(struct islpci_acl *acl, char *mac) prism54_mac_accept() argument
1960 if (mutex_lock_interruptible(&acl->lock)) prism54_mac_accept()
1963 if (acl->policy == MAC_POLICY_OPEN) { prism54_mac_accept()
1964 mutex_unlock(&acl->lock); prism54_mac_accept()
1968 list_for_each_entry(entry, &acl->mac_list, _list) { prism54_mac_accept()
1974 res = (acl->policy == MAC_POLICY_ACCEPT) ? !res : res; prism54_mac_accept()
1975 mutex_unlock(&acl->lock); prism54_mac_accept()
2252 mlme->code = prism54_mac_accept(&priv->acl, handle_request()
|
| H A D | islpci_dev.h | 106 struct islpci_acl acl; member in struct:__anon8593
|
| H A D | islpci_dev.c | 718 prism54_acl_init(&priv->acl); islpci_alloc_memory()
777 prism54_acl_clean(&priv->acl); islpci_free_memory()
|
| /linux-4.4.14/drivers/net/ethernet/rocker/ |
| H A D | rocker.c | 112 } acl; member in union:rocker_flow_tbl_key::__anon7712
2055 entry->key.acl.in_pport)) rocker_cmd_flow_tbl_add_acl()
2058 entry->key.acl.in_pport_mask)) rocker_cmd_flow_tbl_add_acl()
2061 ETH_ALEN, entry->key.acl.eth_src)) rocker_cmd_flow_tbl_add_acl()
2064 ETH_ALEN, entry->key.acl.eth_src_mask)) rocker_cmd_flow_tbl_add_acl()
2067 ETH_ALEN, entry->key.acl.eth_dst)) rocker_cmd_flow_tbl_add_acl()
2070 ETH_ALEN, entry->key.acl.eth_dst_mask)) rocker_cmd_flow_tbl_add_acl()
2073 entry->key.acl.eth_type)) rocker_cmd_flow_tbl_add_acl()
2076 entry->key.acl.vlan_id)) rocker_cmd_flow_tbl_add_acl()
2079 entry->key.acl.vlan_id_mask)) rocker_cmd_flow_tbl_add_acl()
2082 switch (ntohs(entry->key.acl.eth_type)) { rocker_cmd_flow_tbl_add_acl()
2086 entry->key.acl.ip_proto)) rocker_cmd_flow_tbl_add_acl()
2090 entry->key.acl.ip_proto_mask)) rocker_cmd_flow_tbl_add_acl()
2093 entry->key.acl.ip_tos & 0x3f)) rocker_cmd_flow_tbl_add_acl()
2097 entry->key.acl.ip_tos_mask & 0x3f)) rocker_cmd_flow_tbl_add_acl()
2100 (entry->key.acl.ip_tos & 0xc0) >> 6)) rocker_cmd_flow_tbl_add_acl()
2104 (entry->key.acl.ip_tos_mask & 0xc0) >> 6)) rocker_cmd_flow_tbl_add_acl()
2109 if (entry->key.acl.group_id != ROCKER_GROUP_NONE && rocker_cmd_flow_tbl_add_acl()
2111 entry->key.acl.group_id)) rocker_cmd_flow_tbl_add_acl()
2699 entry->key.acl.in_pport = in_pport; rocker_flow_tbl_acl()
2700 entry->key.acl.in_pport_mask = in_pport_mask; rocker_flow_tbl_acl()
2703 ether_addr_copy(entry->key.acl.eth_src, eth_src); rocker_flow_tbl_acl()
2705 ether_addr_copy(entry->key.acl.eth_src_mask, eth_src_mask); rocker_flow_tbl_acl()
2707 ether_addr_copy(entry->key.acl.eth_dst, eth_dst); rocker_flow_tbl_acl()
2709 ether_addr_copy(entry->key.acl.eth_dst_mask, eth_dst_mask); rocker_flow_tbl_acl()
2711 entry->key.acl.eth_type = eth_type; rocker_flow_tbl_acl()
2712 entry->key.acl.vlan_id = vlan_id; rocker_flow_tbl_acl()
2713 entry->key.acl.vlan_id_mask = vlan_id_mask; rocker_flow_tbl_acl()
2714 entry->key.acl.ip_proto = ip_proto; rocker_flow_tbl_acl()
2715 entry->key.acl.ip_proto_mask = ip_proto_mask; rocker_flow_tbl_acl()
2716 entry->key.acl.ip_tos = ip_tos; rocker_flow_tbl_acl()
2717 entry->key.acl.ip_tos_mask = ip_tos_mask; rocker_flow_tbl_acl()
2718 entry->key.acl.group_id = group_id; rocker_flow_tbl_acl()
3239 bool acl; member in struct:rocker_ctrl
3248 .acl = true,
3255 .acl = true,
3282 .acl = true,
3373 if (ctrl->acl) rocker_port_ctrl_vlan()
|
| /linux-4.4.14/drivers/staging/lustre/lustre/mdc/ |
| H A D | mdc_request.c | 117 * because mdt_getattr*() _always_ returns 4 fields, but if acl is not needed
414 struct posix_acl *acl; mdc_unpack_acl() local
426 acl = posix_acl_from_xattr(&init_user_ns, buf, body->aclsize); mdc_unpack_acl()
427 if (acl == NULL) mdc_unpack_acl()
430 if (IS_ERR(acl)) { mdc_unpack_acl()
431 rc = PTR_ERR(acl); mdc_unpack_acl()
432 CERROR("convert xattr to acl: %d\n", rc); mdc_unpack_acl()
436 rc = posix_acl_valid(acl); mdc_unpack_acl()
438 CERROR("validate acl: %d\n", rc); mdc_unpack_acl()
439 posix_acl_release(acl); mdc_unpack_acl()
443 md->posix_acl = acl; mdc_unpack_acl()
|
| H A D | mdc_locks.c | 1055 * a separate permissions lock for owner/group/acl that mdc_revalidate_lock()
|
| /linux-4.4.14/drivers/bluetooth/ |
| H A D | btwilink.c | 59 /* Increments HCI counters based on pocket ID (cmd,acl,sco) */ ti_st_tx_complete()
|
| /linux-4.4.14/fs/cifs/ |
| H A D | cifsacl.c | 550 /* validate that we do not go past end of acl */ dump_ace()
601 /* validate that we do not go past end of acl */ parse_dacl()
1057 struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */ id_mode_to_cifs_acl()
1058 struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */ id_mode_to_cifs_acl()
|
| H A D | cifs_debug.c | 144 seq_printf(m, " acl"); cifs_debug_data_proc_show()
|
| H A D | cifsfs.c | 490 seq_puts(s, ",acl"); cifs_show_options()
|
| H A D | cifssmb.c | 3445 cifs_dbg(FYI, "setting acl with %d entries from buf of length %d and version of %d\n", ACL_to_cifs_posix()
3885 cifs_dbg(VFS, "acl length %d does not match %d\n", CIFSSMBGetCIFSACL()
3891 /* check if buffer is big enough for the acl CIFSSMBGetCIFSACL()
3895 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen); CIFSSMBGetCIFSACL()
|
| H A D | cifsglob.h | 469 bool no_psx_acl:1; /* set if posix acl support should be disabled */
|
| H A D | connect.c | 163 { Opt_acl, "acl" },
3209 cifs_dbg(FYI, "negotiated posix acl support\n"); reset_cifs_unix_caps()
|
| H A D | cifspdu.h | 1288 /* Currently only ioctl, acl (get security descriptor) */
|
| /linux-4.4.14/include/target/ |
| H A D | target_core_fabric.h | 168 void core_allocate_nexus_loss_ua(struct se_node_acl *acl);
|
| /linux-4.4.14/net/wireless/ |
| H A D | nl80211.c | 3141 struct cfg80211_acl_data *acl; parse_acl_data() local
3165 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries), parse_acl_data()
3167 if (!acl) parse_acl_data()
3171 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN); parse_acl_data()
3175 acl->n_acl_entries = n_entries; parse_acl_data()
3176 acl->acl_policy = acl_policy; parse_acl_data()
3178 return acl; parse_acl_data()
3185 struct cfg80211_acl_data *acl; nl80211_set_mac_acl() local
3195 acl = parse_acl_data(&rdev->wiphy, info); nl80211_set_mac_acl()
3196 if (IS_ERR(acl)) nl80211_set_mac_acl()
3197 return PTR_ERR(acl); nl80211_set_mac_acl()
3199 err = rdev_set_mac_acl(rdev, dev, acl); nl80211_set_mac_acl()
3201 kfree(acl); nl80211_set_mac_acl()
3459 params.acl = parse_acl_data(&rdev->wiphy, info); nl80211_start_ap()
3460 if (IS_ERR(params.acl)) nl80211_start_ap()
3461 return PTR_ERR(params.acl); nl80211_start_ap()
3475 kfree(params.acl); nl80211_start_ap()
|
| H A D | trace.h | 1866 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d",
|
| /linux-4.4.14/drivers/staging/comedi/drivers/ |
| H A D | pcl812.c | 28 * ACL-8112HG (acl8112hg), ACL-8113 (acl-8113), ACL-8216 (acl8216),
|
| /linux-4.4.14/net/bluetooth/rfcomm/ |
| H A D | tty.c | 191 /* Just because the acl link is in the hash table is no rfcomm_reparent_device()
|
| /linux-4.4.14/drivers/scsi/qla2xxx/ |
| H A D | tcm_qla2xxx.c | 665 * Most likely a new dynamic acl has been added while tcm_qla2xxx_clear_nacl_from_fcport_map()
|
| /linux-4.4.14/drivers/staging/lustre/lustre/ptlrpc/ |
| H A D | layout.c | 1029 DEFINE_MSGF("acl", RMF_F_NO_SIZE_CHECK,
|
| /linux-4.4.14/drivers/net/ethernet/chelsio/cxgb4/ |
| H A D | t4fw_api.h | 2993 } acl; member in union:fw_error_cmd::fw_error
|
| /linux-4.4.14/drivers/nvme/host/ |
| H A D | pci.c | 2634 dev->abort_limit = ctrl->acl + 1; nvme_dev_add()
|
| /linux-4.4.14/include/net/ |
| H A D | cfg80211.h | 713 * @acl: ACL configuration used by the drivers which has support for
732 const struct cfg80211_acl_data *acl; member in struct:cfg80211_ap_settings
|
| /linux-4.4.14/drivers/staging/lustre/lustre/include/lustre/ |
| H A D | lustre_idl.h | 2106 * owner, group, acl etc), so to separate the permission from LOOKUP lock.
|