1 /* 2 * security/tomoyo/common.h 3 * 4 * Header file for TOMOYO. 5 * 6 * Copyright (C) 2005-2010 NTT DATA CORPORATION 7 */ 8 9 #ifndef _SECURITY_TOMOYO_COMMON_H 10 #define _SECURITY_TOMOYO_COMMON_H 11 12 #include <linux/ctype.h> 13 #include <linux/string.h> 14 #include <linux/mm.h> 15 #include <linux/file.h> 16 #include <linux/kmod.h> 17 #include <linux/fs.h> 18 #include <linux/sched.h> 19 #include <linux/namei.h> 20 #include <linux/mount.h> 21 #include <linux/list.h> 22 #include <linux/cred.h> 23 #include <linux/poll.h> 24 #include <linux/binfmts.h> 25 #include <linux/highmem.h> 26 27 /********** Constants definitions. **********/ 28 29 /* 30 * TOMOYO uses this hash only when appending a string into the string 31 * table. Frequency of appending strings is very low. So we don't need 32 * large (e.g. 64k) hash size. 256 will be sufficient. 33 */ 34 #define TOMOYO_HASH_BITS 8 35 #define TOMOYO_MAX_HASH (1u<<TOMOYO_HASH_BITS) 36 37 #define TOMOYO_EXEC_TMPSIZE 4096 38 39 /* Profile number is an integer between 0 and 255. */ 40 #define TOMOYO_MAX_PROFILES 256 41 42 /* Group number is an integer between 0 and 255. */ 43 #define TOMOYO_MAX_ACL_GROUPS 256 44 45 /* Index numbers for "struct tomoyo_condition". */ 46 enum tomoyo_conditions_index { 47 TOMOYO_TASK_UID, /* current_uid() */ 48 TOMOYO_TASK_EUID, /* current_euid() */ 49 TOMOYO_TASK_SUID, /* current_suid() */ 50 TOMOYO_TASK_FSUID, /* current_fsuid() */ 51 TOMOYO_TASK_GID, /* current_gid() */ 52 TOMOYO_TASK_EGID, /* current_egid() */ 53 TOMOYO_TASK_SGID, /* current_sgid() */ 54 TOMOYO_TASK_FSGID, /* current_fsgid() */ 55 TOMOYO_TASK_PID, /* sys_getpid() */ 56 TOMOYO_TASK_PPID, /* sys_getppid() */ 57 TOMOYO_EXEC_ARGC, /* "struct linux_binprm *"->argc */ 58 TOMOYO_EXEC_ENVC, /* "struct linux_binprm *"->envc */ 59 TOMOYO_TYPE_IS_SOCKET, /* S_IFSOCK */ 60 TOMOYO_TYPE_IS_SYMLINK, /* S_IFLNK */ 61 TOMOYO_TYPE_IS_FILE, /* S_IFREG */ 62 TOMOYO_TYPE_IS_BLOCK_DEV, /* S_IFBLK */ 63 TOMOYO_TYPE_IS_DIRECTORY, /* S_IFDIR */ 64 TOMOYO_TYPE_IS_CHAR_DEV, /* S_IFCHR */ 65 TOMOYO_TYPE_IS_FIFO, /* S_IFIFO */ 66 TOMOYO_MODE_SETUID, /* S_ISUID */ 67 TOMOYO_MODE_SETGID, /* S_ISGID */ 68 TOMOYO_MODE_STICKY, /* S_ISVTX */ 69 TOMOYO_MODE_OWNER_READ, /* S_IRUSR */ 70 TOMOYO_MODE_OWNER_WRITE, /* S_IWUSR */ 71 TOMOYO_MODE_OWNER_EXECUTE, /* S_IXUSR */ 72 TOMOYO_MODE_GROUP_READ, /* S_IRGRP */ 73 TOMOYO_MODE_GROUP_WRITE, /* S_IWGRP */ 74 TOMOYO_MODE_GROUP_EXECUTE, /* S_IXGRP */ 75 TOMOYO_MODE_OTHERS_READ, /* S_IROTH */ 76 TOMOYO_MODE_OTHERS_WRITE, /* S_IWOTH */ 77 TOMOYO_MODE_OTHERS_EXECUTE, /* S_IXOTH */ 78 TOMOYO_EXEC_REALPATH, 79 TOMOYO_SYMLINK_TARGET, 80 TOMOYO_PATH1_UID, 81 TOMOYO_PATH1_GID, 82 TOMOYO_PATH1_INO, 83 TOMOYO_PATH1_MAJOR, 84 TOMOYO_PATH1_MINOR, 85 TOMOYO_PATH1_PERM, 86 TOMOYO_PATH1_TYPE, 87 TOMOYO_PATH1_DEV_MAJOR, 88 TOMOYO_PATH1_DEV_MINOR, 89 TOMOYO_PATH2_UID, 90 TOMOYO_PATH2_GID, 91 TOMOYO_PATH2_INO, 92 TOMOYO_PATH2_MAJOR, 93 TOMOYO_PATH2_MINOR, 94 TOMOYO_PATH2_PERM, 95 TOMOYO_PATH2_TYPE, 96 TOMOYO_PATH2_DEV_MAJOR, 97 TOMOYO_PATH2_DEV_MINOR, 98 TOMOYO_PATH1_PARENT_UID, 99 TOMOYO_PATH1_PARENT_GID, 100 TOMOYO_PATH1_PARENT_INO, 101 TOMOYO_PATH1_PARENT_PERM, 102 TOMOYO_PATH2_PARENT_UID, 103 TOMOYO_PATH2_PARENT_GID, 104 TOMOYO_PATH2_PARENT_INO, 105 TOMOYO_PATH2_PARENT_PERM, 106 TOMOYO_MAX_CONDITION_KEYWORD, 107 TOMOYO_NUMBER_UNION, 108 TOMOYO_NAME_UNION, 109 TOMOYO_ARGV_ENTRY, 110 TOMOYO_ENVP_ENTRY, 111 }; 112 113 114 /* Index numbers for stat(). */ 115 enum tomoyo_path_stat_index { 116 /* Do not change this order. */ 117 TOMOYO_PATH1, 118 TOMOYO_PATH1_PARENT, 119 TOMOYO_PATH2, 120 TOMOYO_PATH2_PARENT, 121 TOMOYO_MAX_PATH_STAT 122 }; 123 124 /* Index numbers for operation mode. */ 125 enum tomoyo_mode_index { 126 TOMOYO_CONFIG_DISABLED, 127 TOMOYO_CONFIG_LEARNING, 128 TOMOYO_CONFIG_PERMISSIVE, 129 TOMOYO_CONFIG_ENFORCING, 130 TOMOYO_CONFIG_MAX_MODE, 131 TOMOYO_CONFIG_WANT_REJECT_LOG = 64, 132 TOMOYO_CONFIG_WANT_GRANT_LOG = 128, 133 TOMOYO_CONFIG_USE_DEFAULT = 255, 134 }; 135 136 /* Index numbers for entry type. */ 137 enum tomoyo_policy_id { 138 TOMOYO_ID_GROUP, 139 TOMOYO_ID_PATH_GROUP, 140 TOMOYO_ID_NUMBER_GROUP, 141 TOMOYO_ID_TRANSITION_CONTROL, 142 TOMOYO_ID_AGGREGATOR, 143 TOMOYO_ID_MANAGER, 144 TOMOYO_ID_CONDITION, 145 TOMOYO_ID_NAME, 146 TOMOYO_ID_ACL, 147 TOMOYO_ID_DOMAIN, 148 TOMOYO_MAX_POLICY 149 }; 150 151 /* Index numbers for domain's attributes. */ 152 enum tomoyo_domain_info_flags_index { 153 /* Quota warnning flag. */ 154 TOMOYO_DIF_QUOTA_WARNED, 155 /* 156 * This domain was unable to create a new domain at 157 * tomoyo_find_next_domain() because the name of the domain to be 158 * created was too long or it could not allocate memory. 159 * More than one process continued execve() without domain transition. 160 */ 161 TOMOYO_DIF_TRANSITION_FAILED, 162 TOMOYO_MAX_DOMAIN_INFO_FLAGS 163 }; 164 165 /* Index numbers for group entries. */ 166 enum tomoyo_group_id { 167 TOMOYO_PATH_GROUP, 168 TOMOYO_NUMBER_GROUP, 169 TOMOYO_MAX_GROUP 170 }; 171 172 /* Index numbers for type of numeric values. */ 173 enum tomoyo_value_type { 174 TOMOYO_VALUE_TYPE_INVALID, 175 TOMOYO_VALUE_TYPE_DECIMAL, 176 TOMOYO_VALUE_TYPE_OCTAL, 177 TOMOYO_VALUE_TYPE_HEXADECIMAL, 178 }; 179 180 /* Index numbers for domain transition control keywords. */ 181 enum tomoyo_transition_type { 182 /* Do not change this order, */ 183 TOMOYO_TRANSITION_CONTROL_NO_RESET, 184 TOMOYO_TRANSITION_CONTROL_RESET, 185 TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE, 186 TOMOYO_TRANSITION_CONTROL_INITIALIZE, 187 TOMOYO_TRANSITION_CONTROL_NO_KEEP, 188 TOMOYO_TRANSITION_CONTROL_KEEP, 189 TOMOYO_MAX_TRANSITION_TYPE 190 }; 191 192 /* Index numbers for Access Controls. */ 193 enum tomoyo_acl_entry_type_index { 194 TOMOYO_TYPE_PATH_ACL, 195 TOMOYO_TYPE_PATH2_ACL, 196 TOMOYO_TYPE_PATH_NUMBER_ACL, 197 TOMOYO_TYPE_MKDEV_ACL, 198 TOMOYO_TYPE_MOUNT_ACL, 199 }; 200 201 /* Index numbers for access controls with one pathname. */ 202 enum tomoyo_path_acl_index { 203 TOMOYO_TYPE_EXECUTE, 204 TOMOYO_TYPE_READ, 205 TOMOYO_TYPE_WRITE, 206 TOMOYO_TYPE_APPEND, 207 TOMOYO_TYPE_UNLINK, 208 TOMOYO_TYPE_GETATTR, 209 TOMOYO_TYPE_RMDIR, 210 TOMOYO_TYPE_TRUNCATE, 211 TOMOYO_TYPE_SYMLINK, 212 TOMOYO_TYPE_CHROOT, 213 TOMOYO_TYPE_UMOUNT, 214 TOMOYO_MAX_PATH_OPERATION 215 }; 216 217 /* Index numbers for /sys/kernel/security/tomoyo/stat interface. */ 218 enum tomoyo_memory_stat_type { 219 TOMOYO_MEMORY_POLICY, 220 TOMOYO_MEMORY_AUDIT, 221 TOMOYO_MEMORY_QUERY, 222 TOMOYO_MAX_MEMORY_STAT 223 }; 224 225 enum tomoyo_mkdev_acl_index { 226 TOMOYO_TYPE_MKBLOCK, 227 TOMOYO_TYPE_MKCHAR, 228 TOMOYO_MAX_MKDEV_OPERATION 229 }; 230 231 /* Index numbers for access controls with two pathnames. */ 232 enum tomoyo_path2_acl_index { 233 TOMOYO_TYPE_LINK, 234 TOMOYO_TYPE_RENAME, 235 TOMOYO_TYPE_PIVOT_ROOT, 236 TOMOYO_MAX_PATH2_OPERATION 237 }; 238 239 /* Index numbers for access controls with one pathname and one number. */ 240 enum tomoyo_path_number_acl_index { 241 TOMOYO_TYPE_CREATE, 242 TOMOYO_TYPE_MKDIR, 243 TOMOYO_TYPE_MKFIFO, 244 TOMOYO_TYPE_MKSOCK, 245 TOMOYO_TYPE_IOCTL, 246 TOMOYO_TYPE_CHMOD, 247 TOMOYO_TYPE_CHOWN, 248 TOMOYO_TYPE_CHGRP, 249 TOMOYO_MAX_PATH_NUMBER_OPERATION 250 }; 251 252 /* Index numbers for /sys/kernel/security/tomoyo/ interfaces. */ 253 enum tomoyo_securityfs_interface_index { 254 TOMOYO_DOMAINPOLICY, 255 TOMOYO_EXCEPTIONPOLICY, 256 TOMOYO_PROCESS_STATUS, 257 TOMOYO_STAT, 258 TOMOYO_SELFDOMAIN, 259 TOMOYO_AUDIT, 260 TOMOYO_VERSION, 261 TOMOYO_PROFILE, 262 TOMOYO_QUERY, 263 TOMOYO_MANAGER 264 }; 265 266 /* Index numbers for special mount operations. */ 267 enum tomoyo_special_mount { 268 TOMOYO_MOUNT_BIND, /* mount --bind /source /dest */ 269 TOMOYO_MOUNT_MOVE, /* mount --move /old /new */ 270 TOMOYO_MOUNT_REMOUNT, /* mount -o remount /dir */ 271 TOMOYO_MOUNT_MAKE_UNBINDABLE, /* mount --make-unbindable /dir */ 272 TOMOYO_MOUNT_MAKE_PRIVATE, /* mount --make-private /dir */ 273 TOMOYO_MOUNT_MAKE_SLAVE, /* mount --make-slave /dir */ 274 TOMOYO_MOUNT_MAKE_SHARED, /* mount --make-shared /dir */ 275 TOMOYO_MAX_SPECIAL_MOUNT 276 }; 277 278 /* Index numbers for functionality. */ 279 enum tomoyo_mac_index { 280 TOMOYO_MAC_FILE_EXECUTE, 281 TOMOYO_MAC_FILE_OPEN, 282 TOMOYO_MAC_FILE_CREATE, 283 TOMOYO_MAC_FILE_UNLINK, 284 TOMOYO_MAC_FILE_GETATTR, 285 TOMOYO_MAC_FILE_MKDIR, 286 TOMOYO_MAC_FILE_RMDIR, 287 TOMOYO_MAC_FILE_MKFIFO, 288 TOMOYO_MAC_FILE_MKSOCK, 289 TOMOYO_MAC_FILE_TRUNCATE, 290 TOMOYO_MAC_FILE_SYMLINK, 291 TOMOYO_MAC_FILE_MKBLOCK, 292 TOMOYO_MAC_FILE_MKCHAR, 293 TOMOYO_MAC_FILE_LINK, 294 TOMOYO_MAC_FILE_RENAME, 295 TOMOYO_MAC_FILE_CHMOD, 296 TOMOYO_MAC_FILE_CHOWN, 297 TOMOYO_MAC_FILE_CHGRP, 298 TOMOYO_MAC_FILE_IOCTL, 299 TOMOYO_MAC_FILE_CHROOT, 300 TOMOYO_MAC_FILE_MOUNT, 301 TOMOYO_MAC_FILE_UMOUNT, 302 TOMOYO_MAC_FILE_PIVOT_ROOT, 303 TOMOYO_MAX_MAC_INDEX 304 }; 305 306 /* Index numbers for category of functionality. */ 307 enum tomoyo_mac_category_index { 308 TOMOYO_MAC_CATEGORY_FILE, 309 TOMOYO_MAX_MAC_CATEGORY_INDEX 310 }; 311 312 /* 313 * Retry this request. Returned by tomoyo_supervisor() if policy violation has 314 * occurred in enforcing mode and the userspace daemon decided to retry. 315 * 316 * We must choose a positive value in order to distinguish "granted" (which is 317 * 0) and "rejected" (which is a negative value) and "retry". 318 */ 319 #define TOMOYO_RETRY_REQUEST 1 320 321 /* Index numbers for /sys/kernel/security/tomoyo/stat interface. */ 322 enum tomoyo_policy_stat_type { 323 /* Do not change this order. */ 324 TOMOYO_STAT_POLICY_UPDATES, 325 TOMOYO_STAT_POLICY_LEARNING, /* == TOMOYO_CONFIG_LEARNING */ 326 TOMOYO_STAT_POLICY_PERMISSIVE, /* == TOMOYO_CONFIG_PERMISSIVE */ 327 TOMOYO_STAT_POLICY_ENFORCING, /* == TOMOYO_CONFIG_ENFORCING */ 328 TOMOYO_MAX_POLICY_STAT 329 }; 330 331 /* Index numbers for profile's PREFERENCE values. */ 332 enum tomoyo_pref_index { 333 TOMOYO_PREF_MAX_AUDIT_LOG, 334 TOMOYO_PREF_MAX_LEARNING_ENTRY, 335 TOMOYO_MAX_PREF 336 }; 337 338 /********** Structure definitions. **********/ 339 340 /* Common header for holding ACL entries. */ 341 struct tomoyo_acl_head { 342 struct list_head list; 343 bool is_deleted; 344 } __packed; 345 346 /* Common header for shared entries. */ 347 struct tomoyo_shared_acl_head { 348 struct list_head list; 349 atomic_t users; 350 } __packed; 351 352 struct tomoyo_policy_namespace; 353 354 /* Structure for request info. */ 355 struct tomoyo_request_info { 356 /* 357 * For holding parameters specific to operations which deal files. 358 * NULL if not dealing files. 359 */ 360 struct tomoyo_obj_info *obj; 361 /* 362 * For holding parameters specific to execve() request. 363 * NULL if not dealing do_execve(). 364 */ 365 struct tomoyo_execve *ee; 366 struct tomoyo_domain_info *domain; 367 /* For holding parameters. */ 368 union { 369 struct { 370 const struct tomoyo_path_info *filename; 371 /* For using wildcards at tomoyo_find_next_domain(). */ 372 const struct tomoyo_path_info *matched_path; 373 /* One of values in "enum tomoyo_path_acl_index". */ 374 u8 operation; 375 } path; 376 struct { 377 const struct tomoyo_path_info *filename1; 378 const struct tomoyo_path_info *filename2; 379 /* One of values in "enum tomoyo_path2_acl_index". */ 380 u8 operation; 381 } path2; 382 struct { 383 const struct tomoyo_path_info *filename; 384 unsigned int mode; 385 unsigned int major; 386 unsigned int minor; 387 /* One of values in "enum tomoyo_mkdev_acl_index". */ 388 u8 operation; 389 } mkdev; 390 struct { 391 const struct tomoyo_path_info *filename; 392 unsigned long number; 393 /* 394 * One of values in 395 * "enum tomoyo_path_number_acl_index". 396 */ 397 u8 operation; 398 } path_number; 399 struct { 400 const struct tomoyo_path_info *type; 401 const struct tomoyo_path_info *dir; 402 const struct tomoyo_path_info *dev; 403 unsigned long flags; 404 int need_dev; 405 } mount; 406 } param; 407 u8 param_type; 408 bool granted; 409 u8 retry; 410 u8 profile; 411 u8 mode; /* One of tomoyo_mode_index . */ 412 u8 type; 413 }; 414 415 /* Structure for holding a token. */ 416 struct tomoyo_path_info { 417 const char *name; 418 u32 hash; /* = full_name_hash(name, strlen(name)) */ 419 u16 const_len; /* = tomoyo_const_part_length(name) */ 420 bool is_dir; /* = tomoyo_strendswith(name, "/") */ 421 bool is_patterned; /* = tomoyo_path_contains_pattern(name) */ 422 }; 423 424 /* Structure for holding string data. */ 425 struct tomoyo_name { 426 struct tomoyo_shared_acl_head head; 427 struct tomoyo_path_info entry; 428 }; 429 430 /* Structure for holding a word. */ 431 struct tomoyo_name_union { 432 /* Either @filename or @group is NULL. */ 433 const struct tomoyo_path_info *filename; 434 struct tomoyo_group *group; 435 }; 436 437 /* Structure for holding a number. */ 438 struct tomoyo_number_union { 439 unsigned long values[2]; 440 struct tomoyo_group *group; /* Maybe NULL. */ 441 /* One of values in "enum tomoyo_value_type". */ 442 u8 value_type[2]; 443 }; 444 445 /* Structure for "path_group"/"number_group" directive. */ 446 struct tomoyo_group { 447 struct tomoyo_shared_acl_head head; 448 const struct tomoyo_path_info *group_name; 449 struct list_head member_list; 450 }; 451 452 /* Structure for "path_group" directive. */ 453 struct tomoyo_path_group { 454 struct tomoyo_acl_head head; 455 const struct tomoyo_path_info *member_name; 456 }; 457 458 /* Structure for "number_group" directive. */ 459 struct tomoyo_number_group { 460 struct tomoyo_acl_head head; 461 struct tomoyo_number_union number; 462 }; 463 464 /* Subset of "struct stat". Used by conditional ACL and audit logs. */ 465 struct tomoyo_mini_stat { 466 uid_t uid; 467 gid_t gid; 468 ino_t ino; 469 mode_t mode; 470 dev_t dev; 471 dev_t rdev; 472 }; 473 474 /* Structure for dumping argv[] and envp[] of "struct linux_binprm". */ 475 struct tomoyo_page_dump { 476 struct page *page; /* Previously dumped page. */ 477 char *data; /* Contents of "page". Size is PAGE_SIZE. */ 478 }; 479 480 /* Structure for attribute checks in addition to pathname checks. */ 481 struct tomoyo_obj_info { 482 /* 483 * True if tomoyo_get_attributes() was already called, false otherwise. 484 */ 485 bool validate_done; 486 /* True if @stat[] is valid. */ 487 bool stat_valid[TOMOYO_MAX_PATH_STAT]; 488 /* First pathname. Initialized with { NULL, NULL } if no path. */ 489 struct path path1; 490 /* Second pathname. Initialized with { NULL, NULL } if no path. */ 491 struct path path2; 492 /* 493 * Information on @path1, @path1's parent directory, @path2, @path2's 494 * parent directory. 495 */ 496 struct tomoyo_mini_stat stat[TOMOYO_MAX_PATH_STAT]; 497 /* 498 * Content of symbolic link to be created. NULL for operations other 499 * than symlink(). 500 */ 501 struct tomoyo_path_info *symlink_target; 502 }; 503 504 /* Structure for argv[]. */ 505 struct tomoyo_argv { 506 unsigned long index; 507 const struct tomoyo_path_info *value; 508 bool is_not; 509 }; 510 511 /* Structure for envp[]. */ 512 struct tomoyo_envp { 513 const struct tomoyo_path_info *name; 514 const struct tomoyo_path_info *value; 515 bool is_not; 516 }; 517 518 /* Structure for execve() operation. */ 519 struct tomoyo_execve { 520 struct tomoyo_request_info r; 521 struct tomoyo_obj_info obj; 522 struct linux_binprm *bprm; 523 /* For dumping argv[] and envp[]. */ 524 struct tomoyo_page_dump dump; 525 /* For temporary use. */ 526 char *tmp; /* Size is TOMOYO_EXEC_TMPSIZE bytes */ 527 }; 528 529 /* Structure for entries which follows "struct tomoyo_condition". */ 530 struct tomoyo_condition_element { 531 /* 532 * Left hand operand. A "struct tomoyo_argv" for TOMOYO_ARGV_ENTRY, a 533 * "struct tomoyo_envp" for TOMOYO_ENVP_ENTRY is attached to the tail 534 * of the array of this struct. 535 */ 536 u8 left; 537 /* 538 * Right hand operand. A "struct tomoyo_number_union" for 539 * TOMOYO_NUMBER_UNION, a "struct tomoyo_name_union" for 540 * TOMOYO_NAME_UNION is attached to the tail of the array of this 541 * struct. 542 */ 543 u8 right; 544 /* Equation operator. True if equals or overlaps, false otherwise. */ 545 bool equals; 546 }; 547 548 /* Structure for optional arguments. */ 549 struct tomoyo_condition { 550 struct tomoyo_shared_acl_head head; 551 u32 size; /* Memory size allocated for this entry. */ 552 u16 condc; /* Number of conditions in this struct. */ 553 u16 numbers_count; /* Number of "struct tomoyo_number_union values". */ 554 u16 names_count; /* Number of "struct tomoyo_name_union names". */ 555 u16 argc; /* Number of "struct tomoyo_argv". */ 556 u16 envc; /* Number of "struct tomoyo_envp". */ 557 /* 558 * struct tomoyo_condition_element condition[condc]; 559 * struct tomoyo_number_union values[numbers_count]; 560 * struct tomoyo_name_union names[names_count]; 561 * struct tomoyo_argv argv[argc]; 562 * struct tomoyo_envp envp[envc]; 563 */ 564 }; 565 566 /* Common header for individual entries. */ 567 struct tomoyo_acl_info { 568 struct list_head list; 569 struct tomoyo_condition *cond; /* Maybe NULL. */ 570 bool is_deleted; 571 u8 type; /* One of values in "enum tomoyo_acl_entry_type_index". */ 572 } __packed; 573 574 /* Structure for domain information. */ 575 struct tomoyo_domain_info { 576 struct list_head list; 577 struct list_head acl_info_list; 578 /* Name of this domain. Never NULL. */ 579 const struct tomoyo_path_info *domainname; 580 /* Namespace for this domain. Never NULL. */ 581 struct tomoyo_policy_namespace *ns; 582 u8 profile; /* Profile number to use. */ 583 u8 group; /* Group number to use. */ 584 bool is_deleted; /* Delete flag. */ 585 bool flags[TOMOYO_MAX_DOMAIN_INFO_FLAGS]; 586 atomic_t users; /* Number of referring credentials. */ 587 }; 588 589 /* 590 * Structure for "file execute", "file read", "file write", "file append", 591 * "file unlink", "file getattr", "file rmdir", "file truncate", 592 * "file symlink", "file chroot" and "file unmount" directive. 593 */ 594 struct tomoyo_path_acl { 595 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */ 596 u16 perm; /* Bitmask of values in "enum tomoyo_path_acl_index". */ 597 struct tomoyo_name_union name; 598 }; 599 600 /* 601 * Structure for "file create", "file mkdir", "file mkfifo", "file mksock", 602 * "file ioctl", "file chmod", "file chown" and "file chgrp" directive. 603 */ 604 struct tomoyo_path_number_acl { 605 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_NUMBER_ACL */ 606 /* Bitmask of values in "enum tomoyo_path_number_acl_index". */ 607 u8 perm; 608 struct tomoyo_name_union name; 609 struct tomoyo_number_union number; 610 }; 611 612 /* Structure for "file mkblock" and "file mkchar" directive. */ 613 struct tomoyo_mkdev_acl { 614 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MKDEV_ACL */ 615 u8 perm; /* Bitmask of values in "enum tomoyo_mkdev_acl_index". */ 616 struct tomoyo_name_union name; 617 struct tomoyo_number_union mode; 618 struct tomoyo_number_union major; 619 struct tomoyo_number_union minor; 620 }; 621 622 /* 623 * Structure for "file rename", "file link" and "file pivot_root" directive. 624 */ 625 struct tomoyo_path2_acl { 626 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH2_ACL */ 627 u8 perm; /* Bitmask of values in "enum tomoyo_path2_acl_index". */ 628 struct tomoyo_name_union name1; 629 struct tomoyo_name_union name2; 630 }; 631 632 /* Structure for "file mount" directive. */ 633 struct tomoyo_mount_acl { 634 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MOUNT_ACL */ 635 struct tomoyo_name_union dev_name; 636 struct tomoyo_name_union dir_name; 637 struct tomoyo_name_union fs_type; 638 struct tomoyo_number_union flags; 639 }; 640 641 /* Structure for holding a line from /sys/kernel/security/tomoyo/ interface. */ 642 struct tomoyo_acl_param { 643 char *data; 644 struct list_head *list; 645 struct tomoyo_policy_namespace *ns; 646 bool is_delete; 647 }; 648 649 #define TOMOYO_MAX_IO_READ_QUEUE 64 650 651 /* 652 * Structure for reading/writing policy via /sys/kernel/security/tomoyo 653 * interfaces. 654 */ 655 struct tomoyo_io_buffer { 656 void (*read) (struct tomoyo_io_buffer *); 657 int (*write) (struct tomoyo_io_buffer *); 658 int (*poll) (struct file *file, poll_table *wait); 659 /* Exclusive lock for this structure. */ 660 struct mutex io_sem; 661 char __user *read_user_buf; 662 size_t read_user_buf_avail; 663 struct { 664 struct list_head *ns; 665 struct list_head *domain; 666 struct list_head *group; 667 struct list_head *acl; 668 size_t avail; 669 unsigned int step; 670 unsigned int query_index; 671 u16 index; 672 u16 cond_index; 673 u8 acl_group_index; 674 u8 cond_step; 675 u8 bit; 676 u8 w_pos; 677 bool eof; 678 bool print_this_domain_only; 679 bool print_transition_related_only; 680 bool print_cond_part; 681 const char *w[TOMOYO_MAX_IO_READ_QUEUE]; 682 } r; 683 struct { 684 struct tomoyo_policy_namespace *ns; 685 /* The position currently writing to. */ 686 struct tomoyo_domain_info *domain; 687 /* Bytes available for writing. */ 688 size_t avail; 689 bool is_delete; 690 } w; 691 /* Buffer for reading. */ 692 char *read_buf; 693 /* Size of read buffer. */ 694 size_t readbuf_size; 695 /* Buffer for writing. */ 696 char *write_buf; 697 /* Size of write buffer. */ 698 size_t writebuf_size; 699 /* Type of this interface. */ 700 enum tomoyo_securityfs_interface_index type; 701 /* Users counter protected by tomoyo_io_buffer_list_lock. */ 702 u8 users; 703 /* List for telling GC not to kfree() elements. */ 704 struct list_head list; 705 }; 706 707 /* 708 * Structure for "initialize_domain"/"no_initialize_domain"/"keep_domain"/ 709 * "no_keep_domain" keyword. 710 */ 711 struct tomoyo_transition_control { 712 struct tomoyo_acl_head head; 713 u8 type; /* One of values in "enum tomoyo_transition_type". */ 714 /* True if the domainname is tomoyo_get_last_name(). */ 715 bool is_last_name; 716 const struct tomoyo_path_info *domainname; /* Maybe NULL */ 717 const struct tomoyo_path_info *program; /* Maybe NULL */ 718 }; 719 720 /* Structure for "aggregator" keyword. */ 721 struct tomoyo_aggregator { 722 struct tomoyo_acl_head head; 723 const struct tomoyo_path_info *original_name; 724 const struct tomoyo_path_info *aggregated_name; 725 }; 726 727 /* Structure for policy manager. */ 728 struct tomoyo_manager { 729 struct tomoyo_acl_head head; 730 bool is_domain; /* True if manager is a domainname. */ 731 /* A path to program or a domainname. */ 732 const struct tomoyo_path_info *manager; 733 }; 734 735 struct tomoyo_preference { 736 unsigned int learning_max_entry; 737 bool enforcing_verbose; 738 bool learning_verbose; 739 bool permissive_verbose; 740 }; 741 742 /* Structure for /sys/kernel/security/tomnoyo/profile interface. */ 743 struct tomoyo_profile { 744 const struct tomoyo_path_info *comment; 745 struct tomoyo_preference *learning; 746 struct tomoyo_preference *permissive; 747 struct tomoyo_preference *enforcing; 748 struct tomoyo_preference preference; 749 u8 default_config; 750 u8 config[TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX]; 751 unsigned int pref[TOMOYO_MAX_PREF]; 752 }; 753 754 /* Structure for representing YYYY/MM/DD hh/mm/ss. */ 755 struct tomoyo_time { 756 u16 year; 757 u8 month; 758 u8 day; 759 u8 hour; 760 u8 min; 761 u8 sec; 762 }; 763 764 /* Structure for policy namespace. */ 765 struct tomoyo_policy_namespace { 766 /* Profile table. Memory is allocated as needed. */ 767 struct tomoyo_profile *profile_ptr[TOMOYO_MAX_PROFILES]; 768 /* List of "struct tomoyo_group". */ 769 struct list_head group_list[TOMOYO_MAX_GROUP]; 770 /* List of policy. */ 771 struct list_head policy_list[TOMOYO_MAX_POLICY]; 772 /* The global ACL referred by "use_group" keyword. */ 773 struct list_head acl_group[TOMOYO_MAX_ACL_GROUPS]; 774 /* List for connecting to tomoyo_namespace_list list. */ 775 struct list_head namespace_list; 776 /* Profile version. Currently only 20100903 is defined. */ 777 unsigned int profile_version; 778 /* Name of this namespace (e.g. "<kernel>", "</usr/sbin/httpd>" ). */ 779 const char *name; 780 }; 781 782 /********** Function prototypes. **********/ 783 784 bool tomoyo_compare_number_union(const unsigned long value, 785 const struct tomoyo_number_union *ptr); 786 bool tomoyo_condition(struct tomoyo_request_info *r, 787 const struct tomoyo_condition *cond); 788 bool tomoyo_correct_domain(const unsigned char *domainname); 789 bool tomoyo_correct_path(const char *filename); 790 bool tomoyo_correct_word(const char *string); 791 bool tomoyo_domain_def(const unsigned char *buffer); 792 bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r); 793 bool tomoyo_dump_page(struct linux_binprm *bprm, unsigned long pos, 794 struct tomoyo_page_dump *dump); 795 bool tomoyo_memory_ok(void *ptr); 796 bool tomoyo_number_matches_group(const unsigned long min, 797 const unsigned long max, 798 const struct tomoyo_group *group); 799 bool tomoyo_parse_name_union(struct tomoyo_acl_param *param, 800 struct tomoyo_name_union *ptr); 801 bool tomoyo_parse_number_union(struct tomoyo_acl_param *param, 802 struct tomoyo_number_union *ptr); 803 bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename, 804 const struct tomoyo_path_info *pattern); 805 bool tomoyo_permstr(const char *string, const char *keyword); 806 bool tomoyo_str_starts(char **src, const char *find); 807 char *tomoyo_encode(const char *str); 808 char *tomoyo_init_log(struct tomoyo_request_info *r, int len, const char *fmt, 809 va_list args); 810 char *tomoyo_read_token(struct tomoyo_acl_param *param); 811 char *tomoyo_realpath_from_path(struct path *path); 812 char *tomoyo_realpath_nofollow(const char *pathname); 813 const char *tomoyo_get_exe(void); 814 const char *tomoyo_yesno(const unsigned int value); 815 const struct tomoyo_path_info *tomoyo_compare_name_union 816 (const struct tomoyo_path_info *name, const struct tomoyo_name_union *ptr); 817 const struct tomoyo_path_info *tomoyo_get_name(const char *name); 818 const struct tomoyo_path_info *tomoyo_path_matches_group 819 (const struct tomoyo_path_info *pathname, const struct tomoyo_group *group); 820 int tomoyo_check_open_permission(struct tomoyo_domain_info *domain, 821 struct path *path, const int flag); 822 int tomoyo_close_control(struct tomoyo_io_buffer *head); 823 int tomoyo_find_next_domain(struct linux_binprm *bprm); 824 int tomoyo_get_mode(const struct tomoyo_policy_namespace *ns, const u8 profile, 825 const u8 index); 826 int tomoyo_init_request_info(struct tomoyo_request_info *r, 827 struct tomoyo_domain_info *domain, 828 const u8 index); 829 int tomoyo_mkdev_perm(const u8 operation, struct path *path, 830 const unsigned int mode, unsigned int dev); 831 int tomoyo_mount_permission(char *dev_name, struct path *path, 832 const char *type, unsigned long flags, 833 void *data_page); 834 int tomoyo_open_control(const u8 type, struct file *file); 835 int tomoyo_path2_perm(const u8 operation, struct path *path1, 836 struct path *path2); 837 int tomoyo_path_number_perm(const u8 operation, struct path *path, 838 unsigned long number); 839 int tomoyo_path_perm(const u8 operation, struct path *path, 840 const char *target); 841 int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation, 842 const struct tomoyo_path_info *filename); 843 int tomoyo_poll_control(struct file *file, poll_table *wait); 844 int tomoyo_poll_log(struct file *file, poll_table *wait); 845 int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...) 846 __printf(2, 3); 847 int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size, 848 struct tomoyo_acl_param *param, 849 bool (*check_duplicate) 850 (const struct tomoyo_acl_info *, 851 const struct tomoyo_acl_info *), 852 bool (*merge_duplicate) 853 (struct tomoyo_acl_info *, struct tomoyo_acl_info *, 854 const bool)); 855 int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size, 856 struct tomoyo_acl_param *param, 857 bool (*check_duplicate) 858 (const struct tomoyo_acl_head *, 859 const struct tomoyo_acl_head *)); 860 int tomoyo_write_aggregator(struct tomoyo_acl_param *param); 861 int tomoyo_write_file(struct tomoyo_acl_param *param); 862 int tomoyo_write_group(struct tomoyo_acl_param *param, const u8 type); 863 int tomoyo_write_transition_control(struct tomoyo_acl_param *param, 864 const u8 type); 865 ssize_t tomoyo_read_control(struct tomoyo_io_buffer *head, char __user *buffer, 866 const int buffer_len); 867 ssize_t tomoyo_write_control(struct tomoyo_io_buffer *head, 868 const char __user *buffer, const int buffer_len); 869 struct tomoyo_condition *tomoyo_get_condition(struct tomoyo_acl_param *param); 870 struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname, 871 const bool transit); 872 struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname); 873 struct tomoyo_group *tomoyo_get_group(struct tomoyo_acl_param *param, 874 const u8 idx); 875 struct tomoyo_policy_namespace *tomoyo_assign_namespace 876 (const char *domainname); 877 struct tomoyo_profile *tomoyo_profile(const struct tomoyo_policy_namespace *ns, 878 const u8 profile); 879 unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain, 880 const u8 index); 881 u8 tomoyo_parse_ulong(unsigned long *result, char **str); 882 void *tomoyo_commit_ok(void *data, const unsigned int size); 883 void __init tomoyo_load_builtin_policy(void); 884 void __init tomoyo_mm_init(void); 885 void tomoyo_check_acl(struct tomoyo_request_info *r, 886 bool (*check_entry) (struct tomoyo_request_info *, 887 const struct tomoyo_acl_info *)); 888 void tomoyo_check_profile(void); 889 void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp); 890 void tomoyo_del_condition(struct list_head *element); 891 void tomoyo_fill_path_info(struct tomoyo_path_info *ptr); 892 void tomoyo_get_attributes(struct tomoyo_obj_info *obj); 893 void tomoyo_init_policy_namespace(struct tomoyo_policy_namespace *ns); 894 void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...) 895 __printf(2, 3); 896 void tomoyo_load_policy(const char *filename); 897 void tomoyo_memory_free(void *ptr); 898 void tomoyo_normalize_line(unsigned char *buffer); 899 void tomoyo_notify_gc(struct tomoyo_io_buffer *head, const bool is_register); 900 void tomoyo_print_ulong(char *buffer, const int buffer_len, 901 const unsigned long value, const u8 type); 902 void tomoyo_put_name_union(struct tomoyo_name_union *ptr); 903 void tomoyo_put_number_union(struct tomoyo_number_union *ptr); 904 void tomoyo_read_log(struct tomoyo_io_buffer *head); 905 void tomoyo_update_stat(const u8 index); 906 void tomoyo_warn_oom(const char *function); 907 void tomoyo_write_log(struct tomoyo_request_info *r, const char *fmt, ...) 908 __printf(2, 3); 909 void tomoyo_write_log2(struct tomoyo_request_info *r, int len, const char *fmt, 910 va_list args); 911 912 /********** External variable definitions. **********/ 913 914 extern bool tomoyo_policy_loaded; 915 extern const char * const tomoyo_condition_keyword 916 [TOMOYO_MAX_CONDITION_KEYWORD]; 917 extern const char * const tomoyo_dif[TOMOYO_MAX_DOMAIN_INFO_FLAGS]; 918 extern const char * const tomoyo_mac_keywords[TOMOYO_MAX_MAC_INDEX 919 + TOMOYO_MAX_MAC_CATEGORY_INDEX]; 920 extern const char * const tomoyo_mode[TOMOYO_CONFIG_MAX_MODE]; 921 extern const char * const tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION]; 922 extern const u8 tomoyo_index2category[TOMOYO_MAX_MAC_INDEX]; 923 extern const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION]; 924 extern const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION]; 925 extern const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION]; 926 extern struct list_head tomoyo_condition_list; 927 extern struct list_head tomoyo_domain_list; 928 extern struct list_head tomoyo_name_list[TOMOYO_MAX_HASH]; 929 extern struct list_head tomoyo_namespace_list; 930 extern struct mutex tomoyo_policy_lock; 931 extern struct srcu_struct tomoyo_ss; 932 extern struct tomoyo_domain_info tomoyo_kernel_domain; 933 extern struct tomoyo_policy_namespace tomoyo_kernel_namespace; 934 extern unsigned int tomoyo_memory_quota[TOMOYO_MAX_MEMORY_STAT]; 935 extern unsigned int tomoyo_memory_used[TOMOYO_MAX_MEMORY_STAT]; 936 937 /********** Inlined functions. **********/ 938 939 /** 940 * tomoyo_read_lock - Take lock for protecting policy. 941 * 942 * Returns index number for tomoyo_read_unlock(). 943 */ 944 static inline int tomoyo_read_lock(void) 945 { 946 return srcu_read_lock(&tomoyo_ss); 947 } 948 949 /** 950 * tomoyo_read_unlock - Release lock for protecting policy. 951 * 952 * @idx: Index number returned by tomoyo_read_lock(). 953 * 954 * Returns nothing. 955 */ 956 static inline void tomoyo_read_unlock(int idx) 957 { 958 srcu_read_unlock(&tomoyo_ss, idx); 959 } 960 961 /** 962 * tomoyo_sys_getppid - Copy of getppid(). 963 * 964 * Returns parent process's PID. 965 * 966 * Alpha does not have getppid() defined. To be able to build this module on 967 * Alpha, I have to copy getppid() from kernel/timer.c. 968 */ 969 static inline pid_t tomoyo_sys_getppid(void) 970 { 971 pid_t pid; 972 rcu_read_lock(); 973 pid = task_tgid_vnr(current->real_parent); 974 rcu_read_unlock(); 975 return pid; 976 } 977 978 /** 979 * tomoyo_sys_getpid - Copy of getpid(). 980 * 981 * Returns current thread's PID. 982 * 983 * Alpha does not have getpid() defined. To be able to build this module on 984 * Alpha, I have to copy getpid() from kernel/timer.c. 985 */ 986 static inline pid_t tomoyo_sys_getpid(void) 987 { 988 return task_tgid_vnr(current); 989 } 990 991 /** 992 * tomoyo_pathcmp - strcmp() for "struct tomoyo_path_info" structure. 993 * 994 * @a: Pointer to "struct tomoyo_path_info". 995 * @b: Pointer to "struct tomoyo_path_info". 996 * 997 * Returns true if @a == @b, false otherwise. 998 */ 999 static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a, 1000 const struct tomoyo_path_info *b) 1001 { 1002 return a->hash != b->hash || strcmp(a->name, b->name); 1003 } 1004 1005 /** 1006 * tomoyo_put_name - Drop reference on "struct tomoyo_name". 1007 * 1008 * @name: Pointer to "struct tomoyo_path_info". Maybe NULL. 1009 * 1010 * Returns nothing. 1011 */ 1012 static inline void tomoyo_put_name(const struct tomoyo_path_info *name) 1013 { 1014 if (name) { 1015 struct tomoyo_name *ptr = 1016 container_of(name, typeof(*ptr), entry); 1017 atomic_dec(&ptr->head.users); 1018 } 1019 } 1020 1021 /** 1022 * tomoyo_put_condition - Drop reference on "struct tomoyo_condition". 1023 * 1024 * @cond: Pointer to "struct tomoyo_condition". Maybe NULL. 1025 * 1026 * Returns nothing. 1027 */ 1028 static inline void tomoyo_put_condition(struct tomoyo_condition *cond) 1029 { 1030 if (cond) 1031 atomic_dec(&cond->head.users); 1032 } 1033 1034 /** 1035 * tomoyo_put_group - Drop reference on "struct tomoyo_group". 1036 * 1037 * @group: Pointer to "struct tomoyo_group". Maybe NULL. 1038 * 1039 * Returns nothing. 1040 */ 1041 static inline void tomoyo_put_group(struct tomoyo_group *group) 1042 { 1043 if (group) 1044 atomic_dec(&group->head.users); 1045 } 1046 1047 /** 1048 * tomoyo_domain - Get "struct tomoyo_domain_info" for current thread. 1049 * 1050 * Returns pointer to "struct tomoyo_domain_info" for current thread. 1051 */ 1052 static inline struct tomoyo_domain_info *tomoyo_domain(void) 1053 { 1054 return current_cred()->security; 1055 } 1056 1057 /** 1058 * tomoyo_real_domain - Get "struct tomoyo_domain_info" for specified thread. 1059 * 1060 * @task: Pointer to "struct task_struct". 1061 * 1062 * Returns pointer to "struct tomoyo_security" for specified thread. 1063 */ 1064 static inline struct tomoyo_domain_info *tomoyo_real_domain(struct task_struct 1065 *task) 1066 { 1067 return task_cred_xxx(task, security); 1068 } 1069 1070 /** 1071 * tomoyo_same_name_union - Check for duplicated "struct tomoyo_name_union" entry. 1072 * 1073 * @a: Pointer to "struct tomoyo_name_union". 1074 * @b: Pointer to "struct tomoyo_name_union". 1075 * 1076 * Returns true if @a == @b, false otherwise. 1077 */ 1078 static inline bool tomoyo_same_name_union 1079 (const struct tomoyo_name_union *a, const struct tomoyo_name_union *b) 1080 { 1081 return a->filename == b->filename && a->group == b->group; 1082 } 1083 1084 /** 1085 * tomoyo_same_number_union - Check for duplicated "struct tomoyo_number_union" entry. 1086 * 1087 * @a: Pointer to "struct tomoyo_number_union". 1088 * @b: Pointer to "struct tomoyo_number_union". 1089 * 1090 * Returns true if @a == @b, false otherwise. 1091 */ 1092 static inline bool tomoyo_same_number_union 1093 (const struct tomoyo_number_union *a, const struct tomoyo_number_union *b) 1094 { 1095 return a->values[0] == b->values[0] && a->values[1] == b->values[1] && 1096 a->group == b->group && a->value_type[0] == b->value_type[0] && 1097 a->value_type[1] == b->value_type[1]; 1098 } 1099 1100 /** 1101 * tomoyo_current_namespace - Get "struct tomoyo_policy_namespace" for current thread. 1102 * 1103 * Returns pointer to "struct tomoyo_policy_namespace" for current thread. 1104 */ 1105 static inline struct tomoyo_policy_namespace *tomoyo_current_namespace(void) 1106 { 1107 return tomoyo_domain()->ns; 1108 } 1109 1110 #if defined(CONFIG_SLOB) 1111 1112 /** 1113 * tomoyo_round2 - Round up to power of 2 for calculating memory usage. 1114 * 1115 * @size: Size to be rounded up. 1116 * 1117 * Returns @size. 1118 * 1119 * Since SLOB does not round up, this function simply returns @size. 1120 */ 1121 static inline int tomoyo_round2(size_t size) 1122 { 1123 return size; 1124 } 1125 1126 #else 1127 1128 /** 1129 * tomoyo_round2 - Round up to power of 2 for calculating memory usage. 1130 * 1131 * @size: Size to be rounded up. 1132 * 1133 * Returns rounded size. 1134 * 1135 * Strictly speaking, SLAB may be able to allocate (e.g.) 96 bytes instead of 1136 * (e.g.) 128 bytes. 1137 */ 1138 static inline int tomoyo_round2(size_t size) 1139 { 1140 #if PAGE_SIZE == 4096 1141 size_t bsize = 32; 1142 #else 1143 size_t bsize = 64; 1144 #endif 1145 if (!size) 1146 return 0; 1147 while (size > bsize) 1148 bsize <<= 1; 1149 return bsize; 1150 } 1151 1152 #endif 1153 1154 /** 1155 * list_for_each_cookie - iterate over a list with cookie. 1156 * @pos: the &struct list_head to use as a loop cursor. 1157 * @head: the head for your list. 1158 */ 1159 #define list_for_each_cookie(pos, head) \ 1160 if (!pos) \ 1161 pos = srcu_dereference((head)->next, &tomoyo_ss); \ 1162 for ( ; pos != (head); pos = srcu_dereference(pos->next, &tomoyo_ss)) 1163 1164 #endif /* !defined(_SECURITY_TOMOYO_COMMON_H) */ 1165