Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

security: whitespace coding style fixes

Whitespace coding style fixes.

Signed-off-by: Justin P. Mattock <justinmattock@gmail.com>
Signed-off-by: James Morris <jmorris@namei.org>

authored by

Justin P. Mattock and committed by
James Morris
c5b60b5e 822cceec

+45 -45
+2 -2
security/commoncap.c
··· 570 570 } 571 571 572 572 if (!strncmp(name, XATTR_SECURITY_PREFIX, 573 - sizeof(XATTR_SECURITY_PREFIX) - 1) && 573 + sizeof(XATTR_SECURITY_PREFIX) - 1) && 574 574 !capable(CAP_SYS_ADMIN)) 575 575 return -EPERM; 576 576 return 0; ··· 596 596 } 597 597 598 598 if (!strncmp(name, XATTR_SECURITY_PREFIX, 599 - sizeof(XATTR_SECURITY_PREFIX) - 1) && 599 + sizeof(XATTR_SECURITY_PREFIX) - 1) && 600 600 !capable(CAP_SYS_ADMIN)) 601 601 return -EPERM; 602 602 return 0;
+1 -1
security/device_cgroup.c
··· 469 469 .name = "devices", 470 470 .can_attach = devcgroup_can_attach, 471 471 .create = devcgroup_create, 472 - .destroy = devcgroup_destroy, 472 + .destroy = devcgroup_destroy, 473 473 .populate = devcgroup_populate, 474 474 .subsys_id = devices_subsys_id, 475 475 };
+1 -1
security/keys/key.c
··· 355 355 */ 356 356 int key_payload_reserve(struct key *key, size_t datalen) 357 357 { 358 - int delta = (int) datalen - key->datalen; 358 + int delta = (int)datalen - key->datalen; 359 359 int ret = 0; 360 360 361 361 key_check(key);
+29 -29
security/keys/keyctl.c
··· 212 212 ret = key->serial; 213 213 214 214 key_put(key); 215 - error5: 215 + error5: 216 216 key_type_put(ktype); 217 - error4: 217 + error4: 218 218 key_ref_put(dest_ref); 219 - error3: 219 + error3: 220 220 kfree(callout_info); 221 - error2: 221 + error2: 222 222 kfree(description); 223 - error: 223 + error: 224 224 return ret; 225 225 226 226 } /* end sys_request_key() */ ··· 246 246 247 247 ret = key_ref_to_ptr(key_ref)->serial; 248 248 key_ref_put(key_ref); 249 - error: 249 + error: 250 250 return ret; 251 251 252 252 } /* end keyctl_get_keyring_ID() */ ··· 275 275 ret = join_session_keyring(name); 276 276 kfree(name); 277 277 278 - error: 278 + error: 279 279 return ret; 280 280 281 281 } /* end keyctl_join_session_keyring() */ ··· 322 322 ret = key_update(key_ref, payload, plen); 323 323 324 324 key_ref_put(key_ref); 325 - error2: 325 + error2: 326 326 kfree(payload); 327 - error: 327 + error: 328 328 return ret; 329 329 330 330 } /* end keyctl_update_key() */ ··· 356 356 ret = 0; 357 357 358 358 key_ref_put(key_ref); 359 - error: 359 + error: 360 360 return ret; 361 361 362 362 } /* end keyctl_revoke_key() */ ··· 381 381 ret = keyring_clear(key_ref_to_ptr(keyring_ref)); 382 382 383 383 key_ref_put(keyring_ref); 384 - error: 384 + error: 385 385 return ret; 386 386 387 387 } /* end keyctl_keyring_clear() */ ··· 413 413 ret = key_link(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref)); 414 414 415 415 key_ref_put(key_ref); 416 - error2: 416 + error2: 417 417 key_ref_put(keyring_ref); 418 - error: 418 + error: 419 419 return ret; 420 420 421 421 } /* end keyctl_keyring_link() */ ··· 447 447 ret = key_unlink(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref)); 448 448 449 449 key_ref_put(key_ref); 450 - error2: 450 + error2: 451 451 key_ref_put(keyring_ref); 452 - error: 452 + error: 453 453 return ret; 454 454 455 455 } /* end keyctl_keyring_unlink() */ ··· 529 529 } 530 530 531 531 kfree(tmpbuf); 532 - error2: 532 + error2: 533 533 key_ref_put(key_ref); 534 - error: 534 + error: 535 535 return ret; 536 536 537 537 } /* end keyctl_describe_key() */ ··· 616 616 617 617 ret = key_ref_to_ptr(key_ref)->serial; 618 618 619 - error6: 619 + error6: 620 620 key_ref_put(key_ref); 621 - error5: 621 + error5: 622 622 key_type_put(ktype); 623 - error4: 623 + error4: 624 624 key_ref_put(dest_ref); 625 - error3: 625 + error3: 626 626 key_ref_put(keyring_ref); 627 - error2: 627 + error2: 628 628 kfree(description); 629 - error: 629 + error: 630 630 return ret; 631 631 632 632 } /* end keyctl_keyring_search() */ ··· 673 673 } 674 674 675 675 /* the key is probably readable - now try to read it */ 676 - can_read_key: 676 + can_read_key: 677 677 ret = key_validate(key); 678 678 if (ret == 0) { 679 679 ret = -EOPNOTSUPP; ··· 686 686 } 687 687 } 688 688 689 - error2: 689 + error2: 690 690 key_put(key); 691 - error: 691 + error: 692 692 return ret; 693 693 694 694 } /* end keyctl_read_key() */ ··· 1282 1282 1283 1283 /* the parent must have the same effective ownership and mustn't be 1284 1284 * SUID/SGID */ 1285 - if (pcred-> uid != mycred->euid || 1285 + if (pcred->uid != mycred->euid || 1286 1286 pcred->euid != mycred->euid || 1287 1287 pcred->suid != mycred->euid || 1288 - pcred-> gid != mycred->egid || 1288 + pcred->gid != mycred->egid || 1289 1289 pcred->egid != mycred->egid || 1290 1290 pcred->sgid != mycred->egid) 1291 1291 goto not_permitted; 1292 1292 1293 1293 /* the keyrings must have the same UID */ 1294 - if (pcred ->tgcred->session_keyring->uid != mycred->euid || 1294 + if (pcred->tgcred->session_keyring->uid != mycred->euid || 1295 1295 mycred->tgcred->session_keyring->uid != mycred->euid) 1296 1296 goto not_permitted; 1297 1297
+10 -10
security/keys/keyring.c
··· 39 39 unsigned bucket = 0; 40 40 41 41 for (; *desc; desc++) 42 - bucket += (unsigned char) *desc; 42 + bucket += (unsigned char)*desc; 43 43 44 44 return bucket & (KEYRING_NAME_HASH_SIZE - 1); 45 45 } ··· 235 235 ret = qty; 236 236 } 237 237 238 - error: 238 + error: 239 239 return ret; 240 240 241 241 } /* end keyring_read() */ ··· 506 506 rcu_read_unlock(); 507 507 return ERR_PTR(-ENOKEY); 508 508 509 - found: 509 + found: 510 510 atomic_inc(&key->usage); 511 511 rcu_read_unlock(); 512 512 return make_key_ref(key, possessed); ··· 563 563 read_unlock(&keyring_name_lock); 564 564 keyring = ERR_PTR(-ENOKEY); 565 565 566 - error: 566 + error: 567 567 return keyring; 568 568 569 569 } /* end find_keyring_by_name() */ ··· 596 596 sp = 0; 597 597 598 598 /* start processing a new keyring */ 599 - descend: 599 + descend: 600 600 if (test_bit(KEY_FLAG_REVOKED, &subtree->flags)) 601 601 goto not_this_keyring; 602 602 ··· 605 605 goto not_this_keyring; 606 606 kix = 0; 607 607 608 - ascend: 608 + ascend: 609 609 /* iterate through the remaining keys in this keyring */ 610 610 for (; kix < keylist->nkeys; kix++) { 611 611 key = keylist->keys[kix]; ··· 631 631 632 632 /* the keyring we're looking at was disqualified or didn't contain a 633 633 * matching key */ 634 - not_this_keyring: 634 + not_this_keyring: 635 635 if (sp > 0) { 636 636 /* resume the checking of a keyring higher up in the tree */ 637 637 sp--; ··· 642 642 643 643 ret = 0; /* no cycles detected */ 644 644 645 - error: 645 + error: 646 646 rcu_read_unlock(); 647 647 return ret; 648 648 649 - too_deep: 649 + too_deep: 650 650 ret = -ELOOP; 651 651 goto error; 652 652 653 - cycle_detected: 653 + cycle_detected: 654 654 ret = -EDEADLK; 655 655 goto error; 656 656
+1 -1
security/keys/permission.c
··· 109 109 } 110 110 } 111 111 112 - error: 112 + error: 113 113 return ret; 114 114 115 115 } /* end key_validate() */
+1 -1
security/keys/proc.c
··· 307 307 static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos) 308 308 { 309 309 (*_pos)++; 310 - return key_user_next((struct rb_node *) v); 310 + return key_user_next((struct rb_node *)v); 311 311 } 312 312 313 313 static void proc_key_users_stop(struct seq_file *p, void *v)