security/smack/smackfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
   4  *
   5  * Authors:
   6  *      Casey Schaufler <casey@schaufler-ca.com>
   7  *      Ahmed S. Darwish <darwish.07@gmail.com>
   8  *
   9  * Special thanks to the authors of selinuxfs.
  10  *
  11  *      Karl MacMillan <kmacmillan@tresys.com>
  12  *      James Morris <jmorris@redhat.com>
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/vmalloc.h>
  17 #include <linux/security.h>
  18 #include <linux/mutex.h>
  19 #include <linux/slab.h>
  20 #include <net/net_namespace.h>
  21 #include <net/cipso_ipv4.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/ctype.h>
  24 #include <linux/audit.h>
  25 #include <linux/magic.h>
  26 #include <linux/fs_context.h>
  27 #include "smack.h"
  28
  29 #define BEBITS  (sizeof(__be32) * 8)
  30 /*
  31  * smackfs pseudo filesystem.
  32  */
  33
  34 enum smk_inos {
  35         SMK_ROOT_INO    = 2,
  36         SMK_LOAD        = 3,    /* load policy */
  37         SMK_CIPSO       = 4,    /* load label -> CIPSO mapping */
  38         SMK_DOI         = 5,    /* CIPSO DOI */
  39         SMK_DIRECT      = 6,    /* CIPSO level indicating direct label */
  40         SMK_AMBIENT     = 7,    /* internet ambient label */
  41         SMK_NET4ADDR    = 8,    /* single label hosts */
  42         SMK_ONLYCAP     = 9,    /* the only "capable" label */
  43         SMK_LOGGING     = 10,   /* logging */
  44         SMK_LOAD_SELF   = 11,   /* task specific rules */
  45         SMK_ACCESSES    = 12,   /* access policy */
  46         SMK_MAPPED      = 13,   /* CIPSO level indicating mapped label */
  47         SMK_LOAD2       = 14,   /* load policy with long labels */
  48         SMK_LOAD_SELF2  = 15,   /* load task specific rules with long labels */
  49         SMK_ACCESS2     = 16,   /* make an access check with long labels */
  50         SMK_CIPSO2      = 17,   /* load long label -> CIPSO mapping */
  51         SMK_REVOKE_SUBJ = 18,   /* set rules with subject label to '-' */
  52         SMK_CHANGE_RULE = 19,   /* change or add rules (long labels) */
  53         SMK_SYSLOG      = 20,   /* change syslog label) */
  54         SMK_PTRACE      = 21,   /* set ptrace rule */
  55 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
  56         SMK_UNCONFINED  = 22,   /* define an unconfined label */
  57 #endif
  58 #if IS_ENABLED(CONFIG_IPV6)
  59         SMK_NET6ADDR    = 23,   /* single label IPv6 hosts */
  60 #endif /* CONFIG_IPV6 */
  61         SMK_RELABEL_SELF = 24, /* relabel possible without CAP_MAC_ADMIN */
  62 };
  63
  64 /*
  65  * List locks
  66  */
  67 static DEFINE_MUTEX(smack_cipso_lock);
  68 static DEFINE_MUTEX(smack_ambient_lock);
  69 static DEFINE_MUTEX(smk_net4addr_lock);
  70 #if IS_ENABLED(CONFIG_IPV6)
  71 static DEFINE_MUTEX(smk_net6addr_lock);
  72 #endif /* CONFIG_IPV6 */
  73
  74 /*
  75  * This is the "ambient" label for network traffic.
  76  * If it isn't somehow marked, use this.
  77  * It can be reset via smackfs/ambient
  78  */
  79 struct smack_known *smack_net_ambient;
  80
  81 /*
  82  * This is the level in a CIPSO header that indicates a
  83  * smack label is contained directly in the category set.
  84  * It can be reset via smackfs/direct
  85  */
  86 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
  87
  88 /*
  89  * This is the level in a CIPSO header that indicates a
  90  * secid is contained directly in the category set.
  91  * It can be reset via smackfs/mapped
  92  */
  93 int smack_cipso_mapped = SMACK_CIPSO_MAPPED_DEFAULT;
  94
  95 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
  96 /*
  97  * Allow one label to be unconfined. This is for
  98  * debugging and application bring-up purposes only.
  99  * It is bad and wrong, but everyone seems to expect
 100  * to have it.
 101  */
 102 struct smack_known *smack_unconfined;
 103 #endif
 104
 105 /*
 106  * If this value is set restrict syslog use to the label specified.
 107  * It can be reset via smackfs/syslog
 108  */
 109 struct smack_known *smack_syslog_label;
 110
 111 /*
 112  * Ptrace current rule
 113  * SMACK_PTRACE_DEFAULT    regular smack ptrace rules (/proc based)
 114  * SMACK_PTRACE_EXACT      labels must match, but can be overriden with
 115  *                         CAP_SYS_PTRACE
 116  * SMACK_PTRACE_DRACONIAN  lables must match, CAP_SYS_PTRACE has no effect
 117  */
 118 int smack_ptrace_rule = SMACK_PTRACE_DEFAULT;
 119
 120 /*
 121  * Certain IP addresses may be designated as single label hosts.
 122  * Packets are sent there unlabeled, but only from tasks that
 123  * can write to the specified label.
 124  */
 125
 126 LIST_HEAD(smk_net4addr_list);
 127 #if IS_ENABLED(CONFIG_IPV6)
 128 LIST_HEAD(smk_net6addr_list);
 129 #endif /* CONFIG_IPV6 */
 130
 131 /*
 132  * Rule lists are maintained for each label.
 133  */
 134 struct smack_parsed_rule {
 135         struct smack_known      *smk_subject;
 136         struct smack_known      *smk_object;
 137         int                     smk_access1;
 138         int                     smk_access2;
 139 };
 140
 141 static int smk_cipso_doi_value = SMACK_CIPSO_DOI_DEFAULT;
 142
 143 /*
 144  * Values for parsing cipso rules
 145  * SMK_DIGITLEN: Length of a digit field in a rule.
 146  * SMK_CIPSOMIN: Minimum possible cipso rule length.
 147  * SMK_CIPSOMAX: Maximum possible cipso rule length.
 148  */
 149 #define SMK_DIGITLEN 4
 150 #define SMK_CIPSOMIN (SMK_LABELLEN + 2 * SMK_DIGITLEN)
 151 #define SMK_CIPSOMAX (SMK_CIPSOMIN + SMACK_CIPSO_MAXCATNUM * SMK_DIGITLEN)
 152
 153 /*
 154  * Values for parsing MAC rules
 155  * SMK_ACCESS: Maximum possible combination of access permissions
 156  * SMK_ACCESSLEN: Maximum length for a rule access field
 157  * SMK_LOADLEN: Smack rule length
 158  */
 159 #define SMK_OACCESS     "rwxa"
 160 #define SMK_ACCESS      "rwxatl"
 161 #define SMK_OACCESSLEN  (sizeof(SMK_OACCESS) - 1)
 162 #define SMK_ACCESSLEN   (sizeof(SMK_ACCESS) - 1)
 163 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
 164 #define SMK_LOADLEN     (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSLEN)
 165
 166 /*
 167  * Stricly for CIPSO level manipulation.
 168  * Set the category bit number in a smack label sized buffer.
 169  */
 170 static inline void smack_catset_bit(unsigned int cat, char *catsetp)
 171 {
 172         if (cat == 0 || cat > (SMK_CIPSOLEN * 8))
 173                 return;
 174
 175         catsetp[(cat - 1) / 8] |= 0x80 >> ((cat - 1) % 8);
 176 }
 177
 178 /**
 179  * smk_netlabel_audit_set - fill a netlbl_audit struct
 180  * @nap: structure to fill
 181  */
 182 static void smk_netlabel_audit_set(struct netlbl_audit *nap)
 183 {
 184         struct smack_known *skp = smk_of_current();
 185
 186         nap->loginuid = audit_get_loginuid(current);
 187         nap->sessionid = audit_get_sessionid(current);
 188         nap->secid = skp->smk_secid;
 189 }
 190
 191 /*
 192  * Value for parsing single label host rules
 193  * "1.2.3.4 X"
 194  */
 195 #define SMK_NETLBLADDRMIN       9
 196
 197 /**
 198  * smk_set_access - add a rule to the rule list or replace an old rule
 199  * @srp: the rule to add or replace
 200  * @rule_list: the list of rules
 201  * @rule_lock: the rule list lock
 202  *
 203  * Looks through the current subject/object/access list for
 204  * the subject/object pair and replaces the access that was
 205  * there. If the pair isn't found add it with the specified
 206  * access.
 207  *
 208  * Returns 0 if nothing goes wrong or -ENOMEM if it fails
 209  * during the allocation of the new pair to add.
 210  */
 211 static int smk_set_access(struct smack_parsed_rule *srp,
 212                                 struct list_head *rule_list,
 213                                 struct mutex *rule_lock)
 214 {
 215         struct smack_rule *sp;
 216         int found = 0;
 217         int rc = 0;
 218
 219         mutex_lock(rule_lock);
 220
 221         /*
 222          * Because the object label is less likely to match
 223          * than the subject label check it first
 224          */
 225         list_for_each_entry_rcu(sp, rule_list, list) {
 226                 if (sp->smk_object == srp->smk_object &&
 227                     sp->smk_subject == srp->smk_subject) {
 228                         found = 1;
 229                         sp->smk_access |= srp->smk_access1;
 230                         sp->smk_access &= ~srp->smk_access2;
 231                         break;
 232                 }
 233         }
 234
 235         if (found == 0) {
 236                 sp = kmem_cache_zalloc(smack_rule_cache, GFP_KERNEL);
 237                 if (sp == NULL) {
 238                         rc = -ENOMEM;
 239                         goto out;
 240                 }
 241
 242                 sp->smk_subject = srp->smk_subject;
 243                 sp->smk_object = srp->smk_object;
 244                 sp->smk_access = srp->smk_access1 & ~srp->smk_access2;
 245
 246                 list_add_rcu(&sp->list, rule_list);
 247         }
 248
 249 out:
 250         mutex_unlock(rule_lock);
 251         return rc;
 252 }
 253
 254 /**
 255  * smk_perm_from_str - parse smack accesses from a text string
 256  * @string: a text string that contains a Smack accesses code
 257  *
 258  * Returns an integer with respective bits set for specified accesses.
 259  */
 260 static int smk_perm_from_str(const char *string)
 261 {
 262         int perm = 0;
 263         const char *cp;
 264
 265         for (cp = string; ; cp++)
 266                 switch (*cp) {
 267                 case '-':
 268                         break;
 269                 case 'r':
 270                 case 'R':
 271                         perm |= MAY_READ;
 272                         break;
 273                 case 'w':
 274                 case 'W':
 275                         perm |= MAY_WRITE;
 276                         break;
 277                 case 'x':
 278                 case 'X':
 279                         perm |= MAY_EXEC;
 280                         break;
 281                 case 'a':
 282                 case 'A':
 283                         perm |= MAY_APPEND;
 284                         break;
 285                 case 't':
 286                 case 'T':
 287                         perm |= MAY_TRANSMUTE;
 288                         break;
 289                 case 'l':
 290                 case 'L':
 291                         perm |= MAY_LOCK;
 292                         break;
 293                 case 'b':
 294                 case 'B':
 295                         perm |= MAY_BRINGUP;
 296                         break;
 297                 default:
 298                         return perm;
 299                 }
 300 }
 301
 302 /**
 303  * smk_fill_rule - Fill Smack rule from strings
 304  * @subject: subject label string
 305  * @object: object label string
 306  * @access1: access string
 307  * @access2: string with permissions to be removed
 308  * @rule: Smack rule
 309  * @import: if non-zero, import labels
 310  * @len: label length limit
 311  *
 312  * Returns 0 on success, appropriate error code on failure.
 313  */
 314 static int smk_fill_rule(const char *subject, const char *object,
 315                                 const char *access1, const char *access2,
 316                                 struct smack_parsed_rule *rule, int import,
 317                                 int len)
 318 {
 319         const char *cp;
 320         struct smack_known *skp;
 321
 322         if (import) {
 323                 rule->smk_subject = smk_import_entry(subject, len);
 324                 if (IS_ERR(rule->smk_subject))
 325                         return PTR_ERR(rule->smk_subject);
 326
 327                 rule->smk_object = smk_import_entry(object, len);
 328                 if (IS_ERR(rule->smk_object))
 329                         return PTR_ERR(rule->smk_object);
 330         } else {
 331                 cp = smk_parse_smack(subject, len);
 332                 if (IS_ERR(cp))
 333                         return PTR_ERR(cp);
 334                 skp = smk_find_entry(cp);
 335                 kfree(cp);
 336                 if (skp == NULL)
 337                         return -ENOENT;
 338                 rule->smk_subject = skp;
 339
 340                 cp = smk_parse_smack(object, len);
 341                 if (IS_ERR(cp))
 342                         return PTR_ERR(cp);
 343                 skp = smk_find_entry(cp);
 344                 kfree(cp);
 345                 if (skp == NULL)
 346                         return -ENOENT;
 347                 rule->smk_object = skp;
 348         }
 349
 350         rule->smk_access1 = smk_perm_from_str(access1);
 351         if (access2)
 352                 rule->smk_access2 = smk_perm_from_str(access2);
 353         else
 354                 rule->smk_access2 = ~rule->smk_access1;
 355
 356         return 0;
 357 }
 358
 359 /**
 360  * smk_parse_rule - parse Smack rule from load string
 361  * @data: string to be parsed whose size is SMK_LOADLEN
 362  * @rule: Smack rule
 363  * @import: if non-zero, import labels
 364  *
 365  * Returns 0 on success, -1 on errors.
 366  */
 367 static int smk_parse_rule(const char *data, struct smack_parsed_rule *rule,
 368                                 int import)
 369 {
 370         int rc;
 371
 372         rc = smk_fill_rule(data, data + SMK_LABELLEN,
 373                            data + SMK_LABELLEN + SMK_LABELLEN, NULL, rule,
 374                            import, SMK_LABELLEN);
 375         return rc;
 376 }
 377
 378 /**
 379  * smk_parse_long_rule - parse Smack rule from rule string
 380  * @data: string to be parsed, null terminated
 381  * @rule: Will be filled with Smack parsed rule
 382  * @import: if non-zero, import labels
 383  * @tokens: numer of substrings expected in data
 384  *
 385  * Returns number of processed bytes on success, -ERRNO on failure.
 386  */
 387 static ssize_t smk_parse_long_rule(char *data, struct smack_parsed_rule *rule,
 388                                 int import, int tokens)
 389 {
 390         ssize_t cnt = 0;
 391         char *tok[4];
 392         int rc;
 393         int i;
 394
 395         /*
 396          * Parsing the rule in-place, filling all white-spaces with '\0'
 397          */
 398         for (i = 0; i < tokens; ++i) {
 399                 while (isspace(data[cnt]))
 400                         data[cnt++] = '\0';
 401
 402                 if (data[cnt] == '\0')
 403                         /* Unexpected end of data */
 404                         return -EINVAL;
 405
 406                 tok[i] = data + cnt;
 407
 408                 while (data[cnt] && !isspace(data[cnt]))
 409                         ++cnt;
 410         }
 411         while (isspace(data[cnt]))
 412                 data[cnt++] = '\0';
 413
 414         while (i < 4)
 415                 tok[i++] = NULL;
 416
 417         rc = smk_fill_rule(tok[0], tok[1], tok[2], tok[3], rule, import, 0);
 418         return rc == 0 ? cnt : rc;
 419 }
 420
 421 #define SMK_FIXED24_FMT 0       /* Fixed 24byte label format */
 422 #define SMK_LONG_FMT    1       /* Variable long label format */
 423 #define SMK_CHANGE_FMT  2       /* Rule modification format */
 424 /**
 425  * smk_write_rules_list - write() for any /smack rule file
 426  * @file: file pointer, not actually used
 427  * @buf: where to get the data from
 428  * @count: bytes sent
 429  * @ppos: where to start - must be 0
 430  * @rule_list: the list of rules to write to
 431  * @rule_lock: lock for the rule list
 432  * @format: /smack/load or /smack/load2 or /smack/change-rule format.
 433  *
 434  * Get one smack access rule from above.
 435  * The format for SMK_LONG_FMT is:
 436  *      "subject<whitespace>object<whitespace>access[<whitespace>...]"
 437  * The format for SMK_FIXED24_FMT is exactly:
 438  *      "subject                 object                  rwxat"
 439  * The format for SMK_CHANGE_FMT is:
 440  *      "subject<whitespace>object<whitespace>
 441  *       acc_enable<whitespace>acc_disable[<whitespace>...]"
 442  */
 443 static ssize_t smk_write_rules_list(struct file *file, const char __user *buf,
 444                                         size_t count, loff_t *ppos,
 445                                         struct list_head *rule_list,
 446                                         struct mutex *rule_lock, int format)
 447 {
 448         struct smack_parsed_rule rule;
 449         char *data;
 450         int rc;
 451         int trunc = 0;
 452         int tokens;
 453         ssize_t cnt = 0;
 454
 455         /*
 456          * No partial writes.
 457          * Enough data must be present.
 458          */
 459         if (*ppos != 0)
 460                 return -EINVAL;
 461
 462         if (format == SMK_FIXED24_FMT) {
 463                 /*
 464                  * Minor hack for backward compatibility
 465                  */
 466                 if (count < SMK_OLOADLEN || count > SMK_LOADLEN)
 467                         return -EINVAL;
 468         } else {
 469                 if (count >= PAGE_SIZE) {
 470                         count = PAGE_SIZE - 1;
 471                         trunc = 1;
 472                 }
 473         }
 474
 475         data = memdup_user_nul(buf, count);
 476         if (IS_ERR(data))
 477                 return PTR_ERR(data);
 478
 479         /*
 480          * In case of parsing only part of user buf,
 481          * avoid having partial rule at the data buffer
 482          */
 483         if (trunc) {
 484                 while (count > 0 && (data[count - 1] != '\n'))
 485                         --count;
 486                 if (count == 0) {
 487                         rc = -EINVAL;
 488                         goto out;
 489                 }
 490         }
 491
 492         data[count] = '\0';
 493         tokens = (format == SMK_CHANGE_FMT ? 4 : 3);
 494         while (cnt < count) {
 495                 if (format == SMK_FIXED24_FMT) {
 496                         rc = smk_parse_rule(data, &rule, 1);
 497                         if (rc < 0)
 498                                 goto out;
 499                         cnt = count;
 500                 } else {
 501                         rc = smk_parse_long_rule(data + cnt, &rule, 1, tokens);
 502                         if (rc < 0)
 503                                 goto out;
 504                         if (rc == 0) {
 505                                 rc = -EINVAL;
 506                                 goto out;
 507                         }
 508                         cnt += rc;
 509                 }
 510
 511                 if (rule_list == NULL)
 512                         rc = smk_set_access(&rule, &rule.smk_subject->smk_rules,
 513                                 &rule.smk_subject->smk_rules_lock);
 514                 else
 515                         rc = smk_set_access(&rule, rule_list, rule_lock);
 516
 517                 if (rc)
 518                         goto out;
 519         }
 520
 521         rc = cnt;
 522 out:
 523         kfree(data);
 524         return rc;
 525 }
 526
 527 /*
 528  * Core logic for smackfs seq list operations.
 529  */
 530
 531 static void *smk_seq_start(struct seq_file *s, loff_t *pos,
 532                                 struct list_head *head)
 533 {
 534         struct list_head *list;
 535         int i = *pos;
 536
 537         rcu_read_lock();
 538         for (list = rcu_dereference(list_next_rcu(head));
 539                 list != head;
 540                 list = rcu_dereference(list_next_rcu(list))) {
 541                 if (i-- == 0)
 542                         return list;
 543         }
 544
 545         return NULL;
 546 }
 547
 548 static void *smk_seq_next(struct seq_file *s, void *v, loff_t *pos,
 549                                 struct list_head *head)
 550 {
 551         struct list_head *list = v;
 552
 553         ++*pos;
 554         list = rcu_dereference(list_next_rcu(list));
 555
 556         return (list == head) ? NULL : list;
 557 }
 558
 559 static void smk_seq_stop(struct seq_file *s, void *v)
 560 {
 561         rcu_read_unlock();
 562 }
 563
 564 static void smk_rule_show(struct seq_file *s, struct smack_rule *srp, int max)
 565 {
 566         /*
 567          * Don't show any rules with label names too long for
 568          * interface file (/smack/load or /smack/load2)
 569          * because you should expect to be able to write
 570          * anything you read back.
 571          */
 572         if (strlen(srp->smk_subject->smk_known) >= max ||
 573             strlen(srp->smk_object->smk_known) >= max)
 574                 return;
 575
 576         if (srp->smk_access == 0)
 577                 return;
 578
 579         seq_printf(s, "%s %s",
 580                    srp->smk_subject->smk_known,
 581                    srp->smk_object->smk_known);
 582
 583         seq_putc(s, ' ');
 584
 585         if (srp->smk_access & MAY_READ)
 586                 seq_putc(s, 'r');
 587         if (srp->smk_access & MAY_WRITE)
 588                 seq_putc(s, 'w');
 589         if (srp->smk_access & MAY_EXEC)
 590                 seq_putc(s, 'x');
 591         if (srp->smk_access & MAY_APPEND)
 592                 seq_putc(s, 'a');
 593         if (srp->smk_access & MAY_TRANSMUTE)
 594                 seq_putc(s, 't');
 595         if (srp->smk_access & MAY_LOCK)
 596                 seq_putc(s, 'l');
 597         if (srp->smk_access & MAY_BRINGUP)
 598                 seq_putc(s, 'b');
 599
 600         seq_putc(s, '\n');
 601 }
 602
 603 /*
 604  * Seq_file read operations for /smack/load
 605  */
 606
 607 static void *load2_seq_start(struct seq_file *s, loff_t *pos)
 608 {
 609         return smk_seq_start(s, pos, &smack_known_list);
 610 }
 611
 612 static void *load2_seq_next(struct seq_file *s, void *v, loff_t *pos)
 613 {
 614         return smk_seq_next(s, v, pos, &smack_known_list);
 615 }
 616
 617 static int load_seq_show(struct seq_file *s, void *v)
 618 {
 619         struct list_head *list = v;
 620         struct smack_rule *srp;
 621         struct smack_known *skp =
 622                 list_entry_rcu(list, struct smack_known, list);
 623
 624         list_for_each_entry_rcu(srp, &skp->smk_rules, list)
 625                 smk_rule_show(s, srp, SMK_LABELLEN);
 626
 627         return 0;
 628 }
 629
 630 static const struct seq_operations load_seq_ops = {
 631         .start = load2_seq_start,
 632         .next  = load2_seq_next,
 633         .show  = load_seq_show,
 634         .stop  = smk_seq_stop,
 635 };
 636
 637 /**
 638  * smk_open_load - open() for /smack/load
 639  * @inode: inode structure representing file
 640  * @file: "load" file pointer
 641  *
 642  * For reading, use load_seq_* seq_file reading operations.
 643  */
 644 static int smk_open_load(struct inode *inode, struct file *file)
 645 {
 646         return seq_open(file, &load_seq_ops);
 647 }
 648
 649 /**
 650  * smk_write_load - write() for /smack/load
 651  * @file: file pointer, not actually used
 652  * @buf: where to get the data from
 653  * @count: bytes sent
 654  * @ppos: where to start - must be 0
 655  *
 656  */
 657 static ssize_t smk_write_load(struct file *file, const char __user *buf,
 658                               size_t count, loff_t *ppos)
 659 {
 660         /*
 661          * Must have privilege.
 662          * No partial writes.
 663          * Enough data must be present.
 664          */
 665         if (!smack_privileged(CAP_MAC_ADMIN))
 666                 return -EPERM;
 667
 668         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
 669                                     SMK_FIXED24_FMT);
 670 }
 671
 672 static const struct file_operations smk_load_ops = {
 673         .open           = smk_open_load,
 674         .read           = seq_read,
 675         .llseek         = seq_lseek,
 676         .write          = smk_write_load,
 677         .release        = seq_release,
 678 };
 679
 680 /**
 681  * smk_cipso_doi - initialize the CIPSO domain
 682  */
 683 static void smk_cipso_doi(void)
 684 {
 685         int rc;
 686         struct cipso_v4_doi *doip;
 687         struct netlbl_audit nai;
 688
 689         smk_netlabel_audit_set(&nai);
 690
 691         rc = netlbl_cfg_map_del(NULL, PF_INET, NULL, NULL, &nai);
 692         if (rc != 0)
 693                 printk(KERN_WARNING "%s:%d remove rc = %d\n",
 694                        __func__, __LINE__, rc);
 695
 696         doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL);
 697         if (doip == NULL)
 698                 panic("smack:  Failed to initialize cipso DOI.\n");
 699         doip->map.std = NULL;
 700         doip->doi = smk_cipso_doi_value;
 701         doip->type = CIPSO_V4_MAP_PASS;
 702         doip->tags[0] = CIPSO_V4_TAG_RBITMAP;
 703         for (rc = 1; rc < CIPSO_V4_TAG_MAXCNT; rc++)
 704                 doip->tags[rc] = CIPSO_V4_TAG_INVALID;
 705
 706         rc = netlbl_cfg_cipsov4_add(doip, &nai);
 707         if (rc != 0) {
 708                 printk(KERN_WARNING "%s:%d cipso add rc = %d\n",
 709                        __func__, __LINE__, rc);
 710                 kfree(doip);
 711                 return;
 712         }
 713         rc = netlbl_cfg_cipsov4_map_add(doip->doi, NULL, NULL, NULL, &nai);
 714         if (rc != 0) {
 715                 printk(KERN_WARNING "%s:%d map add rc = %d\n",
 716                        __func__, __LINE__, rc);
 717                 kfree(doip);
 718                 return;
 719         }
 720 }
 721
 722 /**
 723  * smk_unlbl_ambient - initialize the unlabeled domain
 724  * @oldambient: previous domain string
 725  */
 726 static void smk_unlbl_ambient(char *oldambient)
 727 {
 728         int rc;
 729         struct netlbl_audit nai;
 730
 731         smk_netlabel_audit_set(&nai);
 732
 733         if (oldambient != NULL) {
 734                 rc = netlbl_cfg_map_del(oldambient, PF_INET, NULL, NULL, &nai);
 735                 if (rc != 0)
 736                         printk(KERN_WARNING "%s:%d remove rc = %d\n",
 737                                __func__, __LINE__, rc);
 738         }
 739         if (smack_net_ambient == NULL)
 740                 smack_net_ambient = &smack_known_floor;
 741
 742         rc = netlbl_cfg_unlbl_map_add(smack_net_ambient->smk_known, PF_INET,
 743                                       NULL, NULL, &nai);
 744         if (rc != 0)
 745                 printk(KERN_WARNING "%s:%d add rc = %d\n",
 746                        __func__, __LINE__, rc);
 747 }
 748
 749 /*
 750  * Seq_file read operations for /smack/cipso
 751  */
 752
 753 static void *cipso_seq_start(struct seq_file *s, loff_t *pos)
 754 {
 755         return smk_seq_start(s, pos, &smack_known_list);
 756 }
 757
 758 static void *cipso_seq_next(struct seq_file *s, void *v, loff_t *pos)
 759 {
 760         return smk_seq_next(s, v, pos, &smack_known_list);
 761 }
 762
 763 /*
 764  * Print cipso labels in format:
 765  * label level[/cat[,cat]]
 766  */
 767 static int cipso_seq_show(struct seq_file *s, void *v)
 768 {
 769         struct list_head  *list = v;
 770         struct smack_known *skp =
 771                 list_entry_rcu(list, struct smack_known, list);
 772         struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
 773         char sep = '/';
 774         int i;
 775
 776         /*
 777          * Don't show a label that could not have been set using
 778          * /smack/cipso. This is in support of the notion that
 779          * anything read from /smack/cipso ought to be writeable
 780          * to /smack/cipso.
 781          *
 782          * /smack/cipso2 should be used instead.
 783          */
 784         if (strlen(skp->smk_known) >= SMK_LABELLEN)
 785                 return 0;
 786
 787         seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
 788
 789         for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
 790              i = netlbl_catmap_walk(cmp, i + 1)) {
 791                 seq_printf(s, "%c%d", sep, i);
 792                 sep = ',';
 793         }
 794
 795         seq_putc(s, '\n');
 796
 797         return 0;
 798 }
 799
 800 static const struct seq_operations cipso_seq_ops = {
 801         .start = cipso_seq_start,
 802         .next  = cipso_seq_next,
 803         .show  = cipso_seq_show,
 804         .stop  = smk_seq_stop,
 805 };
 806
 807 /**
 808  * smk_open_cipso - open() for /smack/cipso
 809  * @inode: inode structure representing file
 810  * @file: "cipso" file pointer
 811  *
 812  * Connect our cipso_seq_* operations with /smack/cipso
 813  * file_operations
 814  */
 815 static int smk_open_cipso(struct inode *inode, struct file *file)
 816 {
 817         return seq_open(file, &cipso_seq_ops);
 818 }
 819
 820 /**
 821  * smk_set_cipso - do the work for write() for cipso and cipso2
 822  * @file: file pointer, not actually used
 823  * @buf: where to get the data from
 824  * @count: bytes sent
 825  * @ppos: where to start
 826  * @format: /smack/cipso or /smack/cipso2
 827  *
 828  * Accepts only one cipso rule per write call.
 829  * Returns number of bytes written or error code, as appropriate
 830  */
 831 static ssize_t smk_set_cipso(struct file *file, const char __user *buf,
 832                                 size_t count, loff_t *ppos, int format)
 833 {
 834         struct smack_known *skp;
 835         struct netlbl_lsm_secattr ncats;
 836         char mapcatset[SMK_CIPSOLEN];
 837         int maplevel;
 838         unsigned int cat;
 839         int catlen;
 840         ssize_t rc = -EINVAL;
 841         char *data = NULL;
 842         char *rule;
 843         int ret;
 844         int i;
 845
 846         /*
 847          * Must have privilege.
 848          * No partial writes.
 849          * Enough data must be present.
 850          */
 851         if (!smack_privileged(CAP_MAC_ADMIN))
 852                 return -EPERM;
 853         if (*ppos != 0)
 854                 return -EINVAL;
 855         if (format == SMK_FIXED24_FMT &&
 856             (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX))
 857                 return -EINVAL;
 858
 859         data = memdup_user_nul(buf, count);
 860         if (IS_ERR(data))
 861                 return PTR_ERR(data);
 862
 863         rule = data;
 864         /*
 865          * Only allow one writer at a time. Writes should be
 866          * quite rare and small in any case.
 867          */
 868         mutex_lock(&smack_cipso_lock);
 869
 870         skp = smk_import_entry(rule, 0);
 871         if (IS_ERR(skp)) {
 872                 rc = PTR_ERR(skp);
 873                 goto out;
 874         }
 875
 876         if (format == SMK_FIXED24_FMT)
 877                 rule += SMK_LABELLEN;
 878         else
 879                 rule += strlen(skp->smk_known) + 1;
 880
 881         if (rule > data + count) {
 882                 rc = -EOVERFLOW;
 883                 goto out;
 884         }
 885
 886         ret = sscanf(rule, "%d", &maplevel);
 887         if (ret != 1 || maplevel < 0 || maplevel > SMACK_CIPSO_MAXLEVEL)
 888                 goto out;
 889
 890         rule += SMK_DIGITLEN;
 891         if (rule > data + count) {
 892                 rc = -EOVERFLOW;
 893                 goto out;
 894         }
 895
 896         ret = sscanf(rule, "%d", &catlen);
 897         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
 898                 goto out;
 899
 900         if (format == SMK_FIXED24_FMT &&
 901             count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
 902                 goto out;
 903
 904         memset(mapcatset, 0, sizeof(mapcatset));
 905
 906         for (i = 0; i < catlen; i++) {
 907                 rule += SMK_DIGITLEN;
 908                 if (rule > data + count) {
 909                         rc = -EOVERFLOW;
 910                         goto out;
 911                 }
 912                 ret = sscanf(rule, "%u", &cat);
 913                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATNUM)
 914                         goto out;
 915
 916                 smack_catset_bit(cat, mapcatset);
 917         }
 918
 919         rc = smk_netlbl_mls(maplevel, mapcatset, &ncats, SMK_CIPSOLEN);
 920         if (rc >= 0) {
 921                 netlbl_catmap_free(skp->smk_netlabel.attr.mls.cat);
 922                 skp->smk_netlabel.attr.mls.cat = ncats.attr.mls.cat;
 923                 skp->smk_netlabel.attr.mls.lvl = ncats.attr.mls.lvl;
 924                 rc = count;
 925                 /*
 926                  * This mapping may have been cached, so clear the cache.
 927                  */
 928                 netlbl_cache_invalidate();
 929         }
 930
 931 out:
 932         mutex_unlock(&smack_cipso_lock);
 933         kfree(data);
 934         return rc;
 935 }
 936
 937 /**
 938  * smk_write_cipso - write() for /smack/cipso
 939  * @file: file pointer, not actually used
 940  * @buf: where to get the data from
 941  * @count: bytes sent
 942  * @ppos: where to start
 943  *
 944  * Accepts only one cipso rule per write call.
 945  * Returns number of bytes written or error code, as appropriate
 946  */
 947 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
 948                                size_t count, loff_t *ppos)
 949 {
 950         return smk_set_cipso(file, buf, count, ppos, SMK_FIXED24_FMT);
 951 }
 952
 953 static const struct file_operations smk_cipso_ops = {
 954         .open           = smk_open_cipso,
 955         .read           = seq_read,
 956         .llseek         = seq_lseek,
 957         .write          = smk_write_cipso,
 958         .release        = seq_release,
 959 };
 960
 961 /*
 962  * Seq_file read operations for /smack/cipso2
 963  */
 964
 965 /*
 966  * Print cipso labels in format:
 967  * label level[/cat[,cat]]
 968  */
 969 static int cipso2_seq_show(struct seq_file *s, void *v)
 970 {
 971         struct list_head  *list = v;
 972         struct smack_known *skp =
 973                 list_entry_rcu(list, struct smack_known, list);
 974         struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
 975         char sep = '/';
 976         int i;
 977
 978         seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
 979
 980         for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
 981              i = netlbl_catmap_walk(cmp, i + 1)) {
 982                 seq_printf(s, "%c%d", sep, i);
 983                 sep = ',';
 984         }
 985
 986         seq_putc(s, '\n');
 987
 988         return 0;
 989 }
 990
 991 static const struct seq_operations cipso2_seq_ops = {
 992         .start = cipso_seq_start,
 993         .next  = cipso_seq_next,
 994         .show  = cipso2_seq_show,
 995         .stop  = smk_seq_stop,
 996 };
 997
 998 /**
 999  * smk_open_cipso2 - open() for /smack/cipso2
1000  * @inode: inode structure representing file
1001  * @file: "cipso2" file pointer
1002  *
1003  * Connect our cipso_seq_* operations with /smack/cipso2
1004  * file_operations
1005  */
1006 static int smk_open_cipso2(struct inode *inode, struct file *file)
1007 {
1008         return seq_open(file, &cipso2_seq_ops);
1009 }
1010
1011 /**
1012  * smk_write_cipso2 - write() for /smack/cipso2
1013  * @file: file pointer, not actually used
1014  * @buf: where to get the data from
1015  * @count: bytes sent
1016  * @ppos: where to start
1017  *
1018  * Accepts only one cipso rule per write call.
1019  * Returns number of bytes written or error code, as appropriate
1020  */
1021 static ssize_t smk_write_cipso2(struct file *file, const char __user *buf,
1022                               size_t count, loff_t *ppos)
1023 {
1024         return smk_set_cipso(file, buf, count, ppos, SMK_LONG_FMT);
1025 }
1026
1027 static const struct file_operations smk_cipso2_ops = {
1028         .open           = smk_open_cipso2,
1029         .read           = seq_read,
1030         .llseek         = seq_lseek,
1031         .write          = smk_write_cipso2,
1032         .release        = seq_release,
1033 };
1034
1035 /*
1036  * Seq_file read operations for /smack/netlabel
1037  */
1038
1039 static void *net4addr_seq_start(struct seq_file *s, loff_t *pos)
1040 {
1041         return smk_seq_start(s, pos, &smk_net4addr_list);
1042 }
1043
1044 static void *net4addr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1045 {
1046         return smk_seq_next(s, v, pos, &smk_net4addr_list);
1047 }
1048
1049 /*
1050  * Print host/label pairs
1051  */
1052 static int net4addr_seq_show(struct seq_file *s, void *v)
1053 {
1054         struct list_head *list = v;
1055         struct smk_net4addr *skp =
1056                         list_entry_rcu(list, struct smk_net4addr, list);
1057         char *kp = SMACK_CIPSO_OPTION;
1058
1059         if (skp->smk_label != NULL)
1060                 kp = skp->smk_label->smk_known;
1061         seq_printf(s, "%pI4/%d %s\n", &skp->smk_host.s_addr,
1062                         skp->smk_masks, kp);
1063
1064         return 0;
1065 }
1066
1067 static const struct seq_operations net4addr_seq_ops = {
1068         .start = net4addr_seq_start,
1069         .next  = net4addr_seq_next,
1070         .show  = net4addr_seq_show,
1071         .stop  = smk_seq_stop,
1072 };
1073
1074 /**
1075  * smk_open_net4addr - open() for /smack/netlabel
1076  * @inode: inode structure representing file
1077  * @file: "netlabel" file pointer
1078  *
1079  * Connect our net4addr_seq_* operations with /smack/netlabel
1080  * file_operations
1081  */
1082 static int smk_open_net4addr(struct inode *inode, struct file *file)
1083 {
1084         return seq_open(file, &net4addr_seq_ops);
1085 }
1086
1087 /**
1088  * smk_net4addr_insert
1089  * @new : netlabel to insert
1090  *
1091  * This helper insert netlabel in the smack_net4addrs list
1092  * sorted by netmask length (longest to smallest)
1093  * locked by &smk_net4addr_lock in smk_write_net4addr
1094  *
1095  */
1096 static void smk_net4addr_insert(struct smk_net4addr *new)
1097 {
1098         struct smk_net4addr *m;
1099         struct smk_net4addr *m_next;
1100
1101         if (list_empty(&smk_net4addr_list)) {
1102                 list_add_rcu(&new->list, &smk_net4addr_list);
1103                 return;
1104         }
1105
1106         m = list_entry_rcu(smk_net4addr_list.next,
1107                            struct smk_net4addr, list);
1108
1109         /* the comparison '>' is a bit hacky, but works */
1110         if (new->smk_masks > m->smk_masks) {
1111                 list_add_rcu(&new->list, &smk_net4addr_list);
1112                 return;
1113         }
1114
1115         list_for_each_entry_rcu(m, &smk_net4addr_list, list) {
1116                 if (list_is_last(&m->list, &smk_net4addr_list)) {
1117                         list_add_rcu(&new->list, &m->list);
1118                         return;
1119                 }
1120                 m_next = list_entry_rcu(m->list.next,
1121                                         struct smk_net4addr, list);
1122                 if (new->smk_masks > m_next->smk_masks) {
1123                         list_add_rcu(&new->list, &m->list);
1124                         return;
1125                 }
1126         }
1127 }
1128
1129
1130 /**
1131  * smk_write_net4addr - write() for /smack/netlabel
1132  * @file: file pointer, not actually used
1133  * @buf: where to get the data from
1134  * @count: bytes sent
1135  * @ppos: where to start
1136  *
1137  * Accepts only one net4addr per write call.
1138  * Returns number of bytes written or error code, as appropriate
1139  */
1140 static ssize_t smk_write_net4addr(struct file *file, const char __user *buf,
1141                                 size_t count, loff_t *ppos)
1142 {
1143         struct smk_net4addr *snp;
1144         struct sockaddr_in newname;
1145         char *smack;
1146         struct smack_known *skp = NULL;
1147         char *data;
1148         char *host = (char *)&newname.sin_addr.s_addr;
1149         int rc;
1150         struct netlbl_audit audit_info;
1151         struct in_addr mask;
1152         unsigned int m;
1153         unsigned int masks;
1154         int found;
1155         u32 mask_bits = (1<<31);
1156         __be32 nsa;
1157         u32 temp_mask;
1158
1159         /*
1160          * Must have privilege.
1161          * No partial writes.
1162          * Enough data must be present.
1163          * "<addr/mask, as a.b.c.d/e><space><label>"
1164          * "<addr, as a.b.c.d><space><label>"
1165          */
1166         if (!smack_privileged(CAP_MAC_ADMIN))
1167                 return -EPERM;
1168         if (*ppos != 0)
1169                 return -EINVAL;
1170         if (count < SMK_NETLBLADDRMIN)
1171                 return -EINVAL;
1172
1173         data = memdup_user_nul(buf, count);
1174         if (IS_ERR(data))
1175                 return PTR_ERR(data);
1176
1177         smack = kzalloc(count + 1, GFP_KERNEL);
1178         if (smack == NULL) {
1179                 rc = -ENOMEM;
1180                 goto free_data_out;
1181         }
1182
1183         rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd/%u %s",
1184                 &host[0], &host[1], &host[2], &host[3], &masks, smack);
1185         if (rc != 6) {
1186                 rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
1187                         &host[0], &host[1], &host[2], &host[3], smack);
1188                 if (rc != 5) {
1189                         rc = -EINVAL;
1190                         goto free_out;
1191                 }
1192                 m = BEBITS;
1193                 masks = 32;
1194         }
1195         if (masks > BEBITS) {
1196                 rc = -EINVAL;
1197                 goto free_out;
1198         }
1199
1200         /*
1201          * If smack begins with '-', it is an option, don't import it
1202          */
1203         if (smack[0] != '-') {
1204                 skp = smk_import_entry(smack, 0);
1205                 if (IS_ERR(skp)) {
1206                         rc = PTR_ERR(skp);
1207                         goto free_out;
1208                 }
1209         } else {
1210                 /*
1211                  * Only the -CIPSO option is supported for IPv4
1212                  */
1213                 if (strcmp(smack, SMACK_CIPSO_OPTION) != 0) {
1214                         rc = -EINVAL;
1215                         goto free_out;
1216                 }
1217         }
1218
1219         for (m = masks, temp_mask = 0; m > 0; m--) {
1220                 temp_mask |= mask_bits;
1221                 mask_bits >>= 1;
1222         }
1223         mask.s_addr = cpu_to_be32(temp_mask);
1224
1225         newname.sin_addr.s_addr &= mask.s_addr;
1226         /*
1227          * Only allow one writer at a time. Writes should be
1228          * quite rare and small in any case.
1229          */
1230         mutex_lock(&smk_net4addr_lock);
1231
1232         nsa = newname.sin_addr.s_addr;
1233         /* try to find if the prefix is already in the list */
1234         found = 0;
1235         list_for_each_entry_rcu(snp, &smk_net4addr_list, list) {
1236                 if (snp->smk_host.s_addr == nsa && snp->smk_masks == masks) {
1237                         found = 1;
1238                         break;
1239                 }
1240         }
1241         smk_netlabel_audit_set(&audit_info);
1242
1243         if (found == 0) {
1244                 snp = kzalloc(sizeof(*snp), GFP_KERNEL);
1245                 if (snp == NULL)
1246                         rc = -ENOMEM;
1247                 else {
1248                         rc = 0;
1249                         snp->smk_host.s_addr = newname.sin_addr.s_addr;
1250                         snp->smk_mask.s_addr = mask.s_addr;
1251                         snp->smk_label = skp;
1252                         snp->smk_masks = masks;
1253                         smk_net4addr_insert(snp);
1254                 }
1255         } else {
1256                 /*
1257                  * Delete the unlabeled entry, only if the previous label
1258                  * wasn't the special CIPSO option
1259                  */
1260                 if (snp->smk_label != NULL)
1261                         rc = netlbl_cfg_unlbl_static_del(&init_net, NULL,
1262                                         &snp->smk_host, &snp->smk_mask,
1263                                         PF_INET, &audit_info);
1264                 else
1265                         rc = 0;
1266                 snp->smk_label = skp;
1267         }
1268
1269         /*
1270          * Now tell netlabel about the single label nature of
1271          * this host so that incoming packets get labeled.
1272          * but only if we didn't get the special CIPSO option
1273          */
1274         if (rc == 0 && skp != NULL)
1275                 rc = netlbl_cfg_unlbl_static_add(&init_net, NULL,
1276                         &snp->smk_host, &snp->smk_mask, PF_INET,
1277                         snp->smk_label->smk_secid, &audit_info);
1278
1279         if (rc == 0)
1280                 rc = count;
1281
1282         mutex_unlock(&smk_net4addr_lock);
1283
1284 free_out:
1285         kfree(smack);
1286 free_data_out:
1287         kfree(data);
1288
1289         return rc;
1290 }
1291
1292 static const struct file_operations smk_net4addr_ops = {
1293         .open           = smk_open_net4addr,
1294         .read           = seq_read,
1295         .llseek         = seq_lseek,
1296         .write          = smk_write_net4addr,
1297         .release        = seq_release,
1298 };
1299
1300 #if IS_ENABLED(CONFIG_IPV6)
1301 /*
1302  * Seq_file read operations for /smack/netlabel6
1303  */
1304
1305 static void *net6addr_seq_start(struct seq_file *s, loff_t *pos)
1306 {
1307         return smk_seq_start(s, pos, &smk_net6addr_list);
1308 }
1309
1310 static void *net6addr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1311 {
1312         return smk_seq_next(s, v, pos, &smk_net6addr_list);
1313 }
1314
1315 /*
1316  * Print host/label pairs
1317  */
1318 static int net6addr_seq_show(struct seq_file *s, void *v)
1319 {
1320         struct list_head *list = v;
1321         struct smk_net6addr *skp =
1322                          list_entry(list, struct smk_net6addr, list);
1323
1324         if (skp->smk_label != NULL)
1325                 seq_printf(s, "%pI6/%d %s\n", &skp->smk_host, skp->smk_masks,
1326                                 skp->smk_label->smk_known);
1327
1328         return 0;
1329 }
1330
1331 static const struct seq_operations net6addr_seq_ops = {
1332         .start = net6addr_seq_start,
1333         .next  = net6addr_seq_next,
1334         .show  = net6addr_seq_show,
1335         .stop  = smk_seq_stop,
1336 };
1337
1338 /**
1339  * smk_open_net6addr - open() for /smack/netlabel
1340  * @inode: inode structure representing file
1341  * @file: "netlabel" file pointer
1342  *
1343  * Connect our net6addr_seq_* operations with /smack/netlabel
1344  * file_operations
1345  */
1346 static int smk_open_net6addr(struct inode *inode, struct file *file)
1347 {
1348         return seq_open(file, &net6addr_seq_ops);
1349 }
1350
1351 /**
1352  * smk_net6addr_insert
1353  * @new : entry to insert
1354  *
1355  * This inserts an entry in the smack_net6addrs list
1356  * sorted by netmask length (longest to smallest)
1357  * locked by &smk_net6addr_lock in smk_write_net6addr
1358  *
1359  */
1360 static void smk_net6addr_insert(struct smk_net6addr *new)
1361 {
1362         struct smk_net6addr *m_next;
1363         struct smk_net6addr *m;
1364
1365         if (list_empty(&smk_net6addr_list)) {
1366                 list_add_rcu(&new->list, &smk_net6addr_list);
1367                 return;
1368         }
1369
1370         m = list_entry_rcu(smk_net6addr_list.next,
1371                            struct smk_net6addr, list);
1372
1373         if (new->smk_masks > m->smk_masks) {
1374                 list_add_rcu(&new->list, &smk_net6addr_list);
1375                 return;
1376         }
1377
1378         list_for_each_entry_rcu(m, &smk_net6addr_list, list) {
1379                 if (list_is_last(&m->list, &smk_net6addr_list)) {
1380                         list_add_rcu(&new->list, &m->list);
1381                         return;
1382                 }
1383                 m_next = list_entry_rcu(m->list.next,
1384                                         struct smk_net6addr, list);
1385                 if (new->smk_masks > m_next->smk_masks) {
1386                         list_add_rcu(&new->list, &m->list);
1387                         return;
1388                 }
1389         }
1390 }
1391
1392
1393 /**
1394  * smk_write_net6addr - write() for /smack/netlabel
1395  * @file: file pointer, not actually used
1396  * @buf: where to get the data from
1397  * @count: bytes sent
1398  * @ppos: where to start
1399  *
1400  * Accepts only one net6addr per write call.
1401  * Returns number of bytes written or error code, as appropriate
1402  */
1403 static ssize_t smk_write_net6addr(struct file *file, const char __user *buf,
1404                                 size_t count, loff_t *ppos)
1405 {
1406         struct smk_net6addr *snp;
1407         struct in6_addr newname;
1408         struct in6_addr fullmask;
1409         struct smack_known *skp = NULL;
1410         char *smack;
1411         char *data;
1412         int rc = 0;
1413         int found = 0;
1414         int i;
1415         unsigned int scanned[8];
1416         unsigned int m;
1417         unsigned int mask = 128;
1418
1419         /*
1420          * Must have privilege.
1421          * No partial writes.
1422          * Enough data must be present.
1423          * "<addr/mask, as a:b:c:d:e:f:g:h/e><space><label>"
1424          * "<addr, as a:b:c:d:e:f:g:h><space><label>"
1425          */
1426         if (!smack_privileged(CAP_MAC_ADMIN))
1427                 return -EPERM;
1428         if (*ppos != 0)
1429                 return -EINVAL;
1430         if (count < SMK_NETLBLADDRMIN)
1431                 return -EINVAL;
1432
1433         data = memdup_user_nul(buf, count);
1434         if (IS_ERR(data))
1435                 return PTR_ERR(data);
1436
1437         smack = kzalloc(count + 1, GFP_KERNEL);
1438         if (smack == NULL) {
1439                 rc = -ENOMEM;
1440                 goto free_data_out;
1441         }
1442
1443         i = sscanf(data, "%x:%x:%x:%x:%x:%x:%x:%x/%u %s",
1444                         &scanned[0], &scanned[1], &scanned[2], &scanned[3],
1445                         &scanned[4], &scanned[5], &scanned[6], &scanned[7],
1446                         &mask, smack);
1447         if (i != 10) {
1448                 i = sscanf(data, "%x:%x:%x:%x:%x:%x:%x:%x %s",
1449                                 &scanned[0], &scanned[1], &scanned[2],
1450                                 &scanned[3], &scanned[4], &scanned[5],
1451                                 &scanned[6], &scanned[7], smack);
1452                 if (i != 9) {
1453                         rc = -EINVAL;
1454                         goto free_out;
1455                 }
1456         }
1457         if (mask > 128) {
1458                 rc = -EINVAL;
1459                 goto free_out;
1460         }
1461         for (i = 0; i < 8; i++) {
1462                 if (scanned[i] > 0xffff) {
1463                         rc = -EINVAL;
1464                         goto free_out;
1465                 }
1466                 newname.s6_addr16[i] = htons(scanned[i]);
1467         }
1468
1469         /*
1470          * If smack begins with '-', it is an option, don't import it
1471          */
1472         if (smack[0] != '-') {
1473                 skp = smk_import_entry(smack, 0);
1474                 if (IS_ERR(skp)) {
1475                         rc = PTR_ERR(skp);
1476                         goto free_out;
1477                 }
1478         } else {
1479                 /*
1480                  * Only -DELETE is supported for IPv6
1481                  */
1482                 if (strcmp(smack, SMACK_DELETE_OPTION) != 0) {
1483                         rc = -EINVAL;
1484                         goto free_out;
1485                 }
1486         }
1487
1488         for (i = 0, m = mask; i < 8; i++) {
1489                 if (m >= 16) {
1490                         fullmask.s6_addr16[i] = 0xffff;
1491                         m -= 16;
1492                 } else if (m > 0) {
1493                         fullmask.s6_addr16[i] = (1 << m) - 1;
1494                         m = 0;
1495                 } else
1496                         fullmask.s6_addr16[i] = 0;
1497                 newname.s6_addr16[i] &= fullmask.s6_addr16[i];
1498         }
1499
1500         /*
1501          * Only allow one writer at a time. Writes should be
1502          * quite rare and small in any case.
1503          */
1504         mutex_lock(&smk_net6addr_lock);
1505         /*
1506          * Try to find the prefix in the list
1507          */
1508         list_for_each_entry_rcu(snp, &smk_net6addr_list, list) {
1509                 if (mask != snp->smk_masks)
1510                         continue;
1511                 for (found = 1, i = 0; i < 8; i++) {
1512                         if (newname.s6_addr16[i] !=
1513                             snp->smk_host.s6_addr16[i]) {
1514                                 found = 0;
1515                                 break;
1516                         }
1517                 }
1518                 if (found == 1)
1519                         break;
1520         }
1521         if (found == 0) {
1522                 snp = kzalloc(sizeof(*snp), GFP_KERNEL);
1523                 if (snp == NULL)
1524                         rc = -ENOMEM;
1525                 else {
1526                         snp->smk_host = newname;
1527                         snp->smk_mask = fullmask;
1528                         snp->smk_masks = mask;
1529                         snp->smk_label = skp;
1530                         smk_net6addr_insert(snp);
1531                 }
1532         } else {
1533                 snp->smk_label = skp;
1534         }
1535
1536         if (rc == 0)
1537                 rc = count;
1538
1539         mutex_unlock(&smk_net6addr_lock);
1540
1541 free_out:
1542         kfree(smack);
1543 free_data_out:
1544         kfree(data);
1545
1546         return rc;
1547 }
1548
1549 static const struct file_operations smk_net6addr_ops = {
1550         .open           = smk_open_net6addr,
1551         .read           = seq_read,
1552         .llseek         = seq_lseek,
1553         .write          = smk_write_net6addr,
1554         .release        = seq_release,
1555 };
1556 #endif /* CONFIG_IPV6 */
1557
1558 /**
1559  * smk_read_doi - read() for /smack/doi
1560  * @filp: file pointer, not actually used
1561  * @buf: where to put the result
1562  * @count: maximum to send along
1563  * @ppos: where to start
1564  *
1565  * Returns number of bytes read or error code, as appropriate
1566  */
1567 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
1568                             size_t count, loff_t *ppos)
1569 {
1570         char temp[80];
1571         ssize_t rc;
1572
1573         if (*ppos != 0)
1574                 return 0;
1575
1576         sprintf(temp, "%d", smk_cipso_doi_value);
1577         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1578
1579         return rc;
1580 }
1581
1582 /**
1583  * smk_write_doi - write() for /smack/doi
1584  * @file: file pointer, not actually used
1585  * @buf: where to get the data from
1586  * @count: bytes sent
1587  * @ppos: where to start
1588  *
1589  * Returns number of bytes written or error code, as appropriate
1590  */
1591 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
1592                              size_t count, loff_t *ppos)
1593 {
1594         char temp[80];
1595         int i;
1596
1597         if (!smack_privileged(CAP_MAC_ADMIN))
1598                 return -EPERM;
1599
1600         if (count >= sizeof(temp) || count == 0)
1601                 return -EINVAL;
1602
1603         if (copy_from_user(temp, buf, count) != 0)
1604                 return -EFAULT;
1605
1606         temp[count] = '\0';
1607
1608         if (sscanf(temp, "%d", &i) != 1)
1609                 return -EINVAL;
1610
1611         smk_cipso_doi_value = i;
1612
1613         smk_cipso_doi();
1614
1615         return count;
1616 }
1617
1618 static const struct file_operations smk_doi_ops = {
1619         .read           = smk_read_doi,
1620         .write          = smk_write_doi,
1621         .llseek         = default_llseek,
1622 };
1623
1624 /**
1625  * smk_read_direct - read() for /smack/direct
1626  * @filp: file pointer, not actually used
1627  * @buf: where to put the result
1628  * @count: maximum to send along
1629  * @ppos: where to start
1630  *
1631  * Returns number of bytes read or error code, as appropriate
1632  */
1633 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
1634                                size_t count, loff_t *ppos)
1635 {
1636         char temp[80];
1637         ssize_t rc;
1638
1639         if (*ppos != 0)
1640                 return 0;
1641
1642         sprintf(temp, "%d", smack_cipso_direct);
1643         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1644
1645         return rc;
1646 }
1647
1648 /**
1649  * smk_write_direct - write() for /smack/direct
1650  * @file: file pointer, not actually used
1651  * @buf: where to get the data from
1652  * @count: bytes sent
1653  * @ppos: where to start
1654  *
1655  * Returns number of bytes written or error code, as appropriate
1656  */
1657 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
1658                                 size_t count, loff_t *ppos)
1659 {
1660         struct smack_known *skp;
1661         char temp[80];
1662         int i;
1663
1664         if (!smack_privileged(CAP_MAC_ADMIN))
1665                 return -EPERM;
1666
1667         if (count >= sizeof(temp) || count == 0)
1668                 return -EINVAL;
1669
1670         if (copy_from_user(temp, buf, count) != 0)
1671                 return -EFAULT;
1672
1673         temp[count] = '\0';
1674
1675         if (sscanf(temp, "%d", &i) != 1)
1676                 return -EINVAL;
1677
1678         /*
1679          * Don't do anything if the value hasn't actually changed.
1680          * If it is changing reset the level on entries that were
1681          * set up to be direct when they were created.
1682          */
1683         if (smack_cipso_direct != i) {
1684                 mutex_lock(&smack_known_lock);
1685                 list_for_each_entry_rcu(skp, &smack_known_list, list)
1686                         if (skp->smk_netlabel.attr.mls.lvl ==
1687                             smack_cipso_direct)
1688                                 skp->smk_netlabel.attr.mls.lvl = i;
1689                 smack_cipso_direct = i;
1690                 mutex_unlock(&smack_known_lock);
1691         }
1692
1693         return count;
1694 }
1695
1696 static const struct file_operations smk_direct_ops = {
1697         .read           = smk_read_direct,
1698         .write          = smk_write_direct,
1699         .llseek         = default_llseek,
1700 };
1701
1702 /**
1703  * smk_read_mapped - read() for /smack/mapped
1704  * @filp: file pointer, not actually used
1705  * @buf: where to put the result
1706  * @count: maximum to send along
1707  * @ppos: where to start
1708  *
1709  * Returns number of bytes read or error code, as appropriate
1710  */
1711 static ssize_t smk_read_mapped(struct file *filp, char __user *buf,
1712                                size_t count, loff_t *ppos)
1713 {
1714         char temp[80];
1715         ssize_t rc;
1716
1717         if (*ppos != 0)
1718                 return 0;
1719
1720         sprintf(temp, "%d", smack_cipso_mapped);
1721         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1722
1723         return rc;
1724 }
1725
1726 /**
1727  * smk_write_mapped - write() for /smack/mapped
1728  * @file: file pointer, not actually used
1729  * @buf: where to get the data from
1730  * @count: bytes sent
1731  * @ppos: where to start
1732  *
1733  * Returns number of bytes written or error code, as appropriate
1734  */
1735 static ssize_t smk_write_mapped(struct file *file, const char __user *buf,
1736                                 size_t count, loff_t *ppos)
1737 {
1738         struct smack_known *skp;
1739         char temp[80];
1740         int i;
1741
1742         if (!smack_privileged(CAP_MAC_ADMIN))
1743                 return -EPERM;
1744
1745         if (count >= sizeof(temp) || count == 0)
1746                 return -EINVAL;
1747
1748         if (copy_from_user(temp, buf, count) != 0)
1749                 return -EFAULT;
1750
1751         temp[count] = '\0';
1752
1753         if (sscanf(temp, "%d", &i) != 1)
1754                 return -EINVAL;
1755
1756         /*
1757          * Don't do anything if the value hasn't actually changed.
1758          * If it is changing reset the level on entries that were
1759          * set up to be mapped when they were created.
1760          */
1761         if (smack_cipso_mapped != i) {
1762                 mutex_lock(&smack_known_lock);
1763                 list_for_each_entry_rcu(skp, &smack_known_list, list)
1764                         if (skp->smk_netlabel.attr.mls.lvl ==
1765                             smack_cipso_mapped)
1766                                 skp->smk_netlabel.attr.mls.lvl = i;
1767                 smack_cipso_mapped = i;
1768                 mutex_unlock(&smack_known_lock);
1769         }
1770
1771         return count;
1772 }
1773
1774 static const struct file_operations smk_mapped_ops = {
1775         .read           = smk_read_mapped,
1776         .write          = smk_write_mapped,
1777         .llseek         = default_llseek,
1778 };
1779
1780 /**
1781  * smk_read_ambient - read() for /smack/ambient
1782  * @filp: file pointer, not actually used
1783  * @buf: where to put the result
1784  * @cn: maximum to send along
1785  * @ppos: where to start
1786  *
1787  * Returns number of bytes read or error code, as appropriate
1788  */
1789 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
1790                                 size_t cn, loff_t *ppos)
1791 {
1792         ssize_t rc;
1793         int asize;
1794
1795         if (*ppos != 0)
1796                 return 0;
1797         /*
1798          * Being careful to avoid a problem in the case where
1799          * smack_net_ambient gets changed in midstream.
1800          */
1801         mutex_lock(&smack_ambient_lock);
1802
1803         asize = strlen(smack_net_ambient->smk_known) + 1;
1804
1805         if (cn >= asize)
1806                 rc = simple_read_from_buffer(buf, cn, ppos,
1807                                              smack_net_ambient->smk_known,
1808                                              asize);
1809         else
1810                 rc = -EINVAL;
1811
1812         mutex_unlock(&smack_ambient_lock);
1813
1814         return rc;
1815 }
1816
1817 /**
1818  * smk_write_ambient - write() for /smack/ambient
1819  * @file: file pointer, not actually used
1820  * @buf: where to get the data from
1821  * @count: bytes sent
1822  * @ppos: where to start
1823  *
1824  * Returns number of bytes written or error code, as appropriate
1825  */
1826 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
1827                                  size_t count, loff_t *ppos)
1828 {
1829         struct smack_known *skp;
1830         char *oldambient;
1831         char *data;
1832         int rc = count;
1833
1834         if (!smack_privileged(CAP_MAC_ADMIN))
1835                 return -EPERM;
1836
1837         data = memdup_user_nul(buf, count);
1838         if (IS_ERR(data))
1839                 return PTR_ERR(data);
1840
1841         skp = smk_import_entry(data, count);
1842         if (IS_ERR(skp)) {
1843                 rc = PTR_ERR(skp);
1844                 goto out;
1845         }
1846
1847         mutex_lock(&smack_ambient_lock);
1848
1849         oldambient = smack_net_ambient->smk_known;
1850         smack_net_ambient = skp;
1851         smk_unlbl_ambient(oldambient);
1852
1853         mutex_unlock(&smack_ambient_lock);
1854
1855 out:
1856         kfree(data);
1857         return rc;
1858 }
1859
1860 static const struct file_operations smk_ambient_ops = {
1861         .read           = smk_read_ambient,
1862         .write          = smk_write_ambient,
1863         .llseek         = default_llseek,
1864 };
1865
1866 /*
1867  * Seq_file operations for /smack/onlycap
1868  */
1869 static void *onlycap_seq_start(struct seq_file *s, loff_t *pos)
1870 {
1871         return smk_seq_start(s, pos, &smack_onlycap_list);
1872 }
1873
1874 static void *onlycap_seq_next(struct seq_file *s, void *v, loff_t *pos)
1875 {
1876         return smk_seq_next(s, v, pos, &smack_onlycap_list);
1877 }
1878
1879 static int onlycap_seq_show(struct seq_file *s, void *v)
1880 {
1881         struct list_head *list = v;
1882         struct smack_known_list_elem *sklep =
1883                 list_entry_rcu(list, struct smack_known_list_elem, list);
1884
1885         seq_puts(s, sklep->smk_label->smk_known);
1886         seq_putc(s, ' ');
1887
1888         return 0;
1889 }
1890
1891 static const struct seq_operations onlycap_seq_ops = {
1892         .start = onlycap_seq_start,
1893         .next  = onlycap_seq_next,
1894         .show  = onlycap_seq_show,
1895         .stop  = smk_seq_stop,
1896 };
1897
1898 static int smk_open_onlycap(struct inode *inode, struct file *file)
1899 {
1900         return seq_open(file, &onlycap_seq_ops);
1901 }
1902
1903 /**
1904  * smk_list_swap_rcu - swap public list with a private one in RCU-safe way
1905  * The caller must hold appropriate mutex to prevent concurrent modifications
1906  * to the public list.
1907  * Private list is assumed to be not accessible to other threads yet.
1908  *
1909  * @public: public list
1910  * @private: private list
1911  */
1912 static void smk_list_swap_rcu(struct list_head *public,
1913                               struct list_head *private)
1914 {
1915         struct list_head *first, *last;
1916
1917         if (list_empty(public)) {
1918                 list_splice_init_rcu(private, public, synchronize_rcu);
1919         } else {
1920                 /* Remember public list before replacing it */
1921                 first = public->next;
1922                 last = public->prev;
1923
1924                 /* Publish private list in place of public in RCU-safe way */
1925                 private->prev->next = public;
1926                 private->next->prev = public;
1927                 rcu_assign_pointer(public->next, private->next);
1928                 public->prev = private->prev;
1929
1930                 synchronize_rcu();
1931
1932                 /* When all readers are done with the old public list,
1933                  * attach it in place of private */
1934                 private->next = first;
1935                 private->prev = last;
1936                 first->prev = private;
1937                 last->next = private;
1938         }
1939 }
1940
1941 /**
1942  * smk_parse_label_list - parse list of Smack labels, separated by spaces
1943  *
1944  * @data: the string to parse
1945  * @private: destination list
1946  *
1947  * Returns zero on success or error code, as appropriate
1948  */
1949 static int smk_parse_label_list(char *data, struct list_head *list)
1950 {
1951         char *tok;
1952         struct smack_known *skp;
1953         struct smack_known_list_elem *sklep;
1954
1955         while ((tok = strsep(&data, " ")) != NULL) {
1956                 if (!*tok)
1957                         continue;
1958
1959                 skp = smk_import_entry(tok, 0);
1960                 if (IS_ERR(skp))
1961                         return PTR_ERR(skp);
1962
1963                 sklep = kzalloc(sizeof(*sklep), GFP_KERNEL);
1964                 if (sklep == NULL)
1965                         return -ENOMEM;
1966
1967                 sklep->smk_label = skp;
1968                 list_add(&sklep->list, list);
1969         }
1970
1971         return 0;
1972 }
1973
1974 /**
1975  * smk_destroy_label_list - destroy a list of smack_known_list_elem
1976  * @head: header pointer of the list to destroy
1977  */
1978 void smk_destroy_label_list(struct list_head *list)
1979 {
1980         struct smack_known_list_elem *sklep;
1981         struct smack_known_list_elem *sklep2;
1982
1983         list_for_each_entry_safe(sklep, sklep2, list, list)
1984                 kfree(sklep);
1985
1986         INIT_LIST_HEAD(list);
1987 }
1988
1989 /**
1990  * smk_write_onlycap - write() for smackfs/onlycap
1991  * @file: file pointer, not actually used
1992  * @buf: where to get the data from
1993  * @count: bytes sent
1994  * @ppos: where to start
1995  *
1996  * Returns number of bytes written or error code, as appropriate
1997  */
1998 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
1999                                  size_t count, loff_t *ppos)
2000 {
2001         char *data;
2002         LIST_HEAD(list_tmp);
2003         int rc;
2004
2005         if (!smack_privileged(CAP_MAC_ADMIN))
2006                 return -EPERM;
2007
2008         data = memdup_user_nul(buf, count);
2009         if (IS_ERR(data))
2010                 return PTR_ERR(data);
2011
2012         rc = smk_parse_label_list(data, &list_tmp);
2013         kfree(data);
2014
2015         /*
2016          * Clear the smack_onlycap on invalid label errors. This means
2017          * that we can pass a null string to unset the onlycap value.
2018          *
2019          * Importing will also reject a label beginning with '-',
2020          * so "-usecapabilities" will also work.
2021          *
2022          * But do so only on invalid label, not on system errors.
2023          * The invalid label must be first to count as clearing attempt.
2024          */
2025         if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
2026                 mutex_lock(&smack_onlycap_lock);
2027                 smk_list_swap_rcu(&smack_onlycap_list, &list_tmp);
2028                 mutex_unlock(&smack_onlycap_lock);
2029                 rc = count;
2030         }
2031
2032         smk_destroy_label_list(&list_tmp);
2033
2034         return rc;
2035 }
2036
2037 static const struct file_operations smk_onlycap_ops = {
2038         .open           = smk_open_onlycap,
2039         .read           = seq_read,
2040         .write          = smk_write_onlycap,
2041         .llseek         = seq_lseek,
2042         .release        = seq_release,
2043 };
2044
2045 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
2046 /**
2047  * smk_read_unconfined - read() for smackfs/unconfined
2048  * @filp: file pointer, not actually used
2049  * @buf: where to put the result
2050  * @cn: maximum to send along
2051  * @ppos: where to start
2052  *
2053  * Returns number of bytes read or error code, as appropriate
2054  */
2055 static ssize_t smk_read_unconfined(struct file *filp, char __user *buf,
2056                                         size_t cn, loff_t *ppos)
2057 {
2058         char *smack = "";
2059         ssize_t rc = -EINVAL;
2060         int asize;
2061
2062         if (*ppos != 0)
2063                 return 0;
2064
2065         if (smack_unconfined != NULL)
2066                 smack = smack_unconfined->smk_known;
2067
2068         asize = strlen(smack) + 1;
2069
2070         if (cn >= asize)
2071                 rc = simple_read_from_buffer(buf, cn, ppos, smack, asize);
2072
2073         return rc;
2074 }
2075
2076 /**
2077  * smk_write_unconfined - write() for smackfs/unconfined
2078  * @file: file pointer, not actually used
2079  * @buf: where to get the data from
2080  * @count: bytes sent
2081  * @ppos: where to start
2082  *
2083  * Returns number of bytes written or error code, as appropriate
2084  */
2085 static ssize_t smk_write_unconfined(struct file *file, const char __user *buf,
2086                                         size_t count, loff_t *ppos)
2087 {
2088         char *data;
2089         struct smack_known *skp;
2090         int rc = count;
2091
2092         if (!smack_privileged(CAP_MAC_ADMIN))
2093                 return -EPERM;
2094
2095         data = memdup_user_nul(buf, count);
2096         if (IS_ERR(data))
2097                 return PTR_ERR(data);
2098
2099         /*
2100          * Clear the smack_unconfined on invalid label errors. This means
2101          * that we can pass a null string to unset the unconfined value.
2102          *
2103          * Importing will also reject a label beginning with '-',
2104          * so "-confine" will also work.
2105          *
2106          * But do so only on invalid label, not on system errors.
2107          */
2108         skp = smk_import_entry(data, count);
2109         if (PTR_ERR(skp) == -EINVAL)
2110                 skp = NULL;
2111         else if (IS_ERR(skp)) {
2112                 rc = PTR_ERR(skp);
2113                 goto freeout;
2114         }
2115
2116         smack_unconfined = skp;
2117
2118 freeout:
2119         kfree(data);
2120         return rc;
2121 }
2122
2123 static const struct file_operations smk_unconfined_ops = {
2124         .read           = smk_read_unconfined,
2125         .write          = smk_write_unconfined,
2126         .llseek         = default_llseek,
2127 };
2128 #endif /* CONFIG_SECURITY_SMACK_BRINGUP */
2129
2130 /**
2131  * smk_read_logging - read() for /smack/logging
2132  * @filp: file pointer, not actually used
2133  * @buf: where to put the result
2134  * @cn: maximum to send along
2135  * @ppos: where to start
2136  *
2137  * Returns number of bytes read or error code, as appropriate
2138  */
2139 static ssize_t smk_read_logging(struct file *filp, char __user *buf,
2140                                 size_t count, loff_t *ppos)
2141 {
2142         char temp[32];
2143         ssize_t rc;
2144
2145         if (*ppos != 0)
2146                 return 0;
2147
2148         sprintf(temp, "%d\n", log_policy);
2149         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2150         return rc;
2151 }
2152
2153 /**
2154  * smk_write_logging - write() for /smack/logging
2155  * @file: file pointer, not actually used
2156  * @buf: where to get the data from
2157  * @count: bytes sent
2158  * @ppos: where to start
2159  *
2160  * Returns number of bytes written or error code, as appropriate
2161  */
2162 static ssize_t smk_write_logging(struct file *file, const char __user *buf,
2163                                 size_t count, loff_t *ppos)
2164 {
2165         char temp[32];
2166         int i;
2167
2168         if (!smack_privileged(CAP_MAC_ADMIN))
2169                 return -EPERM;
2170
2171         if (count >= sizeof(temp) || count == 0)
2172                 return -EINVAL;
2173
2174         if (copy_from_user(temp, buf, count) != 0)
2175                 return -EFAULT;
2176
2177         temp[count] = '\0';
2178
2179         if (sscanf(temp, "%d", &i) != 1)
2180                 return -EINVAL;
2181         if (i < 0 || i > 3)
2182                 return -EINVAL;
2183         log_policy = i;
2184         return count;
2185 }
2186
2187
2188
2189 static const struct file_operations smk_logging_ops = {
2190         .read           = smk_read_logging,
2191         .write          = smk_write_logging,
2192         .llseek         = default_llseek,
2193 };
2194
2195 /*
2196  * Seq_file read operations for /smack/load-self
2197  */
2198
2199 static void *load_self_seq_start(struct seq_file *s, loff_t *pos)
2200 {
2201         struct task_smack *tsp = smack_cred(current_cred());
2202
2203         return smk_seq_start(s, pos, &tsp->smk_rules);
2204 }
2205
2206 static void *load_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
2207 {
2208         struct task_smack *tsp = smack_cred(current_cred());
2209
2210         return smk_seq_next(s, v, pos, &tsp->smk_rules);
2211 }
2212
2213 static int load_self_seq_show(struct seq_file *s, void *v)
2214 {
2215         struct list_head *list = v;
2216         struct smack_rule *srp =
2217                 list_entry_rcu(list, struct smack_rule, list);
2218
2219         smk_rule_show(s, srp, SMK_LABELLEN);
2220
2221         return 0;
2222 }
2223
2224 static const struct seq_operations load_self_seq_ops = {
2225         .start = load_self_seq_start,
2226         .next  = load_self_seq_next,
2227         .show  = load_self_seq_show,
2228         .stop  = smk_seq_stop,
2229 };
2230
2231
2232 /**
2233  * smk_open_load_self - open() for /smack/load-self2
2234  * @inode: inode structure representing file
2235  * @file: "load" file pointer
2236  *
2237  * For reading, use load_seq_* seq_file reading operations.
2238  */
2239 static int smk_open_load_self(struct inode *inode, struct file *file)
2240 {
2241         return seq_open(file, &load_self_seq_ops);
2242 }
2243
2244 /**
2245  * smk_write_load_self - write() for /smack/load-self
2246  * @file: file pointer, not actually used
2247  * @buf: where to get the data from
2248  * @count: bytes sent
2249  * @ppos: where to start - must be 0
2250  *
2251  */
2252 static ssize_t smk_write_load_self(struct file *file, const char __user *buf,
2253                               size_t count, loff_t *ppos)
2254 {
2255         struct task_smack *tsp = smack_cred(current_cred());
2256
2257         return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2258                                     &tsp->smk_rules_lock, SMK_FIXED24_FMT);
2259 }
2260
2261 static const struct file_operations smk_load_self_ops = {
2262         .open           = smk_open_load_self,
2263         .read           = seq_read,
2264         .llseek         = seq_lseek,
2265         .write          = smk_write_load_self,
2266         .release        = seq_release,
2267 };
2268
2269 /**
2270  * smk_user_access - handle access check transaction
2271  * @file: file pointer
2272  * @buf: data from user space
2273  * @count: bytes sent
2274  * @ppos: where to start - must be 0
2275  */
2276 static ssize_t smk_user_access(struct file *file, const char __user *buf,
2277                                 size_t count, loff_t *ppos, int format)
2278 {
2279         struct smack_parsed_rule rule;
2280         char *data;
2281         int res;
2282
2283         data = simple_transaction_get(file, buf, count);
2284         if (IS_ERR(data))
2285                 return PTR_ERR(data);
2286
2287         if (format == SMK_FIXED24_FMT) {
2288                 if (count < SMK_LOADLEN)
2289                         return -EINVAL;
2290                 res = smk_parse_rule(data, &rule, 0);
2291         } else {
2292                 /*
2293                  * simple_transaction_get() returns null-terminated data
2294                  */
2295                 res = smk_parse_long_rule(data, &rule, 0, 3);
2296         }
2297
2298         if (res >= 0)
2299                 res = smk_access(rule.smk_subject, rule.smk_object,
2300                                  rule.smk_access1, NULL);
2301         else if (res != -ENOENT)
2302                 return res;
2303
2304         /*
2305          * smk_access() can return a value > 0 in the "bringup" case.
2306          */
2307         data[0] = res >= 0 ? '1' : '0';
2308         data[1] = '\0';
2309
2310         simple_transaction_set(file, 2);
2311
2312         if (format == SMK_FIXED24_FMT)
2313                 return SMK_LOADLEN;
2314         return count;
2315 }
2316
2317 /**
2318  * smk_write_access - handle access check transaction
2319  * @file: file pointer
2320  * @buf: data from user space
2321  * @count: bytes sent
2322  * @ppos: where to start - must be 0
2323  */
2324 static ssize_t smk_write_access(struct file *file, const char __user *buf,
2325                                 size_t count, loff_t *ppos)
2326 {
2327         return smk_user_access(file, buf, count, ppos, SMK_FIXED24_FMT);
2328 }
2329
2330 static const struct file_operations smk_access_ops = {
2331         .write          = smk_write_access,
2332         .read           = simple_transaction_read,
2333         .release        = simple_transaction_release,
2334         .llseek         = generic_file_llseek,
2335 };
2336
2337
2338 /*
2339  * Seq_file read operations for /smack/load2
2340  */
2341
2342 static int load2_seq_show(struct seq_file *s, void *v)
2343 {
2344         struct list_head *list = v;
2345         struct smack_rule *srp;
2346         struct smack_known *skp =
2347                 list_entry_rcu(list, struct smack_known, list);
2348
2349         list_for_each_entry_rcu(srp, &skp->smk_rules, list)
2350                 smk_rule_show(s, srp, SMK_LONGLABEL);
2351
2352         return 0;
2353 }
2354
2355 static const struct seq_operations load2_seq_ops = {
2356         .start = load2_seq_start,
2357         .next  = load2_seq_next,
2358         .show  = load2_seq_show,
2359         .stop  = smk_seq_stop,
2360 };
2361
2362 /**
2363  * smk_open_load2 - open() for /smack/load2
2364  * @inode: inode structure representing file
2365  * @file: "load2" file pointer
2366  *
2367  * For reading, use load2_seq_* seq_file reading operations.
2368  */
2369 static int smk_open_load2(struct inode *inode, struct file *file)
2370 {
2371         return seq_open(file, &load2_seq_ops);
2372 }
2373
2374 /**
2375  * smk_write_load2 - write() for /smack/load2
2376  * @file: file pointer, not actually used
2377  * @buf: where to get the data from
2378  * @count: bytes sent
2379  * @ppos: where to start - must be 0
2380  *
2381  */
2382 static ssize_t smk_write_load2(struct file *file, const char __user *buf,
2383                                 size_t count, loff_t *ppos)
2384 {
2385         /*
2386          * Must have privilege.
2387          */
2388         if (!smack_privileged(CAP_MAC_ADMIN))
2389                 return -EPERM;
2390
2391         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2392                                     SMK_LONG_FMT);
2393 }
2394
2395 static const struct file_operations smk_load2_ops = {
2396         .open           = smk_open_load2,
2397         .read           = seq_read,
2398         .llseek         = seq_lseek,
2399         .write          = smk_write_load2,
2400         .release        = seq_release,
2401 };
2402
2403 /*
2404  * Seq_file read operations for /smack/load-self2
2405  */
2406
2407 static void *load_self2_seq_start(struct seq_file *s, loff_t *pos)
2408 {
2409         struct task_smack *tsp = smack_cred(current_cred());
2410
2411         return smk_seq_start(s, pos, &tsp->smk_rules);
2412 }
2413
2414 static void *load_self2_seq_next(struct seq_file *s, void *v, loff_t *pos)
2415 {
2416         struct task_smack *tsp = smack_cred(current_cred());
2417
2418         return smk_seq_next(s, v, pos, &tsp->smk_rules);
2419 }
2420
2421 static int load_self2_seq_show(struct seq_file *s, void *v)
2422 {
2423         struct list_head *list = v;
2424         struct smack_rule *srp =
2425                 list_entry_rcu(list, struct smack_rule, list);
2426
2427         smk_rule_show(s, srp, SMK_LONGLABEL);
2428
2429         return 0;
2430 }
2431
2432 static const struct seq_operations load_self2_seq_ops = {
2433         .start = load_self2_seq_start,
2434         .next  = load_self2_seq_next,
2435         .show  = load_self2_seq_show,
2436         .stop  = smk_seq_stop,
2437 };
2438
2439 /**
2440  * smk_open_load_self2 - open() for /smack/load-self2
2441  * @inode: inode structure representing file
2442  * @file: "load" file pointer
2443  *
2444  * For reading, use load_seq_* seq_file reading operations.
2445  */
2446 static int smk_open_load_self2(struct inode *inode, struct file *file)
2447 {
2448         return seq_open(file, &load_self2_seq_ops);
2449 }
2450
2451 /**
2452  * smk_write_load_self2 - write() for /smack/load-self2
2453  * @file: file pointer, not actually used
2454  * @buf: where to get the data from
2455  * @count: bytes sent
2456  * @ppos: where to start - must be 0
2457  *
2458  */
2459 static ssize_t smk_write_load_self2(struct file *file, const char __user *buf,
2460                               size_t count, loff_t *ppos)
2461 {
2462         struct task_smack *tsp = smack_cred(current_cred());
2463
2464         return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2465                                     &tsp->smk_rules_lock, SMK_LONG_FMT);
2466 }
2467
2468 static const struct file_operations smk_load_self2_ops = {
2469         .open           = smk_open_load_self2,
2470         .read           = seq_read,
2471         .llseek         = seq_lseek,
2472         .write          = smk_write_load_self2,
2473         .release        = seq_release,
2474 };
2475
2476 /**
2477  * smk_write_access2 - handle access check transaction
2478  * @file: file pointer
2479  * @buf: data from user space
2480  * @count: bytes sent
2481  * @ppos: where to start - must be 0
2482  */
2483 static ssize_t smk_write_access2(struct file *file, const char __user *buf,
2484                                         size_t count, loff_t *ppos)
2485 {
2486         return smk_user_access(file, buf, count, ppos, SMK_LONG_FMT);
2487 }
2488
2489 static const struct file_operations smk_access2_ops = {
2490         .write          = smk_write_access2,
2491         .read           = simple_transaction_read,
2492         .release        = simple_transaction_release,
2493         .llseek         = generic_file_llseek,
2494 };
2495
2496 /**
2497  * smk_write_revoke_subj - write() for /smack/revoke-subject
2498  * @file: file pointer
2499  * @buf: data from user space
2500  * @count: bytes sent
2501  * @ppos: where to start - must be 0
2502  */
2503 static ssize_t smk_write_revoke_subj(struct file *file, const char __user *buf,
2504                                 size_t count, loff_t *ppos)
2505 {
2506         char *data;
2507         const char *cp;
2508         struct smack_known *skp;
2509         struct smack_rule *sp;
2510         struct list_head *rule_list;
2511         struct mutex *rule_lock;
2512         int rc = count;
2513
2514         if (*ppos != 0)
2515                 return -EINVAL;
2516
2517         if (!smack_privileged(CAP_MAC_ADMIN))
2518                 return -EPERM;
2519
2520         if (count == 0 || count > SMK_LONGLABEL)
2521                 return -EINVAL;
2522
2523         data = memdup_user(buf, count);
2524         if (IS_ERR(data))
2525                 return PTR_ERR(data);
2526
2527         cp = smk_parse_smack(data, count);
2528         if (IS_ERR(cp)) {
2529                 rc = PTR_ERR(cp);
2530                 goto out_data;
2531         }
2532
2533         skp = smk_find_entry(cp);
2534         if (skp == NULL)
2535                 goto out_cp;
2536
2537         rule_list = &skp->smk_rules;
2538         rule_lock = &skp->smk_rules_lock;
2539
2540         mutex_lock(rule_lock);
2541
2542         list_for_each_entry_rcu(sp, rule_list, list)
2543                 sp->smk_access = 0;
2544
2545         mutex_unlock(rule_lock);
2546
2547 out_cp:
2548         kfree(cp);
2549 out_data:
2550         kfree(data);
2551
2552         return rc;
2553 }
2554
2555 static const struct file_operations smk_revoke_subj_ops = {
2556         .write          = smk_write_revoke_subj,
2557         .read           = simple_transaction_read,
2558         .release        = simple_transaction_release,
2559         .llseek         = generic_file_llseek,
2560 };
2561
2562 /**
2563  * smk_init_sysfs - initialize /sys/fs/smackfs
2564  *
2565  */
2566 static int smk_init_sysfs(void)
2567 {
2568         return sysfs_create_mount_point(fs_kobj, "smackfs");
2569 }
2570
2571 /**
2572  * smk_write_change_rule - write() for /smack/change-rule
2573  * @file: file pointer
2574  * @buf: data from user space
2575  * @count: bytes sent
2576  * @ppos: where to start - must be 0
2577  */
2578 static ssize_t smk_write_change_rule(struct file *file, const char __user *buf,
2579                                 size_t count, loff_t *ppos)
2580 {
2581         /*
2582          * Must have privilege.
2583          */
2584         if (!smack_privileged(CAP_MAC_ADMIN))
2585                 return -EPERM;
2586
2587         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2588                                     SMK_CHANGE_FMT);
2589 }
2590
2591 static const struct file_operations smk_change_rule_ops = {
2592         .write          = smk_write_change_rule,
2593         .read           = simple_transaction_read,
2594         .release        = simple_transaction_release,
2595         .llseek         = generic_file_llseek,
2596 };
2597
2598 /**
2599  * smk_read_syslog - read() for smackfs/syslog
2600  * @filp: file pointer, not actually used
2601  * @buf: where to put the result
2602  * @cn: maximum to send along
2603  * @ppos: where to start
2604  *
2605  * Returns number of bytes read or error code, as appropriate
2606  */
2607 static ssize_t smk_read_syslog(struct file *filp, char __user *buf,
2608                                 size_t cn, loff_t *ppos)
2609 {
2610         struct smack_known *skp;
2611         ssize_t rc = -EINVAL;
2612         int asize;
2613
2614         if (*ppos != 0)
2615                 return 0;
2616
2617         if (smack_syslog_label == NULL)
2618                 skp = &smack_known_star;
2619         else
2620                 skp = smack_syslog_label;
2621
2622         asize = strlen(skp->smk_known) + 1;
2623
2624         if (cn >= asize)
2625                 rc = simple_read_from_buffer(buf, cn, ppos, skp->smk_known,
2626                                                 asize);
2627
2628         return rc;
2629 }
2630
2631 /**
2632  * smk_write_syslog - write() for smackfs/syslog
2633  * @file: file pointer, not actually used
2634  * @buf: where to get the data from
2635  * @count: bytes sent
2636  * @ppos: where to start
2637  *
2638  * Returns number of bytes written or error code, as appropriate
2639  */
2640 static ssize_t smk_write_syslog(struct file *file, const char __user *buf,
2641                                 size_t count, loff_t *ppos)
2642 {
2643         char *data;
2644         struct smack_known *skp;
2645         int rc = count;
2646
2647         if (!smack_privileged(CAP_MAC_ADMIN))
2648                 return -EPERM;
2649
2650         data = memdup_user_nul(buf, count);
2651         if (IS_ERR(data))
2652                 return PTR_ERR(data);
2653
2654         skp = smk_import_entry(data, count);
2655         if (IS_ERR(skp))
2656                 rc = PTR_ERR(skp);
2657         else
2658                 smack_syslog_label = skp;
2659
2660         kfree(data);
2661         return rc;
2662 }
2663
2664 static const struct file_operations smk_syslog_ops = {
2665         .read           = smk_read_syslog,
2666         .write          = smk_write_syslog,
2667         .llseek         = default_llseek,
2668 };
2669
2670 /*
2671  * Seq_file read operations for /smack/relabel-self
2672  */
2673
2674 static void *relabel_self_seq_start(struct seq_file *s, loff_t *pos)
2675 {
2676         struct task_smack *tsp = smack_cred(current_cred());
2677
2678         return smk_seq_start(s, pos, &tsp->smk_relabel);
2679 }
2680
2681 static void *relabel_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
2682 {
2683         struct task_smack *tsp = smack_cred(current_cred());
2684
2685         return smk_seq_next(s, v, pos, &tsp->smk_relabel);
2686 }
2687
2688 static int relabel_self_seq_show(struct seq_file *s, void *v)
2689 {
2690         struct list_head *list = v;
2691         struct smack_known_list_elem *sklep =
2692                 list_entry(list, struct smack_known_list_elem, list);
2693
2694         seq_puts(s, sklep->smk_label->smk_known);
2695         seq_putc(s, ' ');
2696
2697         return 0;
2698 }
2699
2700 static const struct seq_operations relabel_self_seq_ops = {
2701         .start = relabel_self_seq_start,
2702         .next  = relabel_self_seq_next,
2703         .show  = relabel_self_seq_show,
2704         .stop  = smk_seq_stop,
2705 };
2706
2707 /**
2708  * smk_open_relabel_self - open() for /smack/relabel-self
2709  * @inode: inode structure representing file
2710  * @file: "relabel-self" file pointer
2711  *
2712  * Connect our relabel_self_seq_* operations with /smack/relabel-self
2713  * file_operations
2714  */
2715 static int smk_open_relabel_self(struct inode *inode, struct file *file)
2716 {
2717         return seq_open(file, &relabel_self_seq_ops);
2718 }
2719
2720 /**
2721  * smk_write_relabel_self - write() for /smack/relabel-self
2722  * @file: file pointer, not actually used
2723  * @buf: where to get the data from
2724  * @count: bytes sent
2725  * @ppos: where to start - must be 0
2726  *
2727  */
2728 static ssize_t smk_write_relabel_self(struct file *file, const char __user *buf,
2729                                 size_t count, loff_t *ppos)
2730 {
2731         char *data;
2732         int rc;
2733         LIST_HEAD(list_tmp);
2734
2735         /*
2736          * Must have privilege.
2737          */
2738         if (!smack_privileged(CAP_MAC_ADMIN))
2739                 return -EPERM;
2740
2741         /*
2742          * Enough data must be present.
2743          */
2744         if (*ppos != 0)
2745                 return -EINVAL;
2746
2747         data = memdup_user_nul(buf, count);
2748         if (IS_ERR(data))
2749                 return PTR_ERR(data);
2750
2751         rc = smk_parse_label_list(data, &list_tmp);
2752         kfree(data);
2753
2754         if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
2755                 struct cred *new;
2756                 struct task_smack *tsp;
2757
2758                 new = prepare_creds();
2759                 if (!new) {
2760                         rc = -ENOMEM;
2761                         goto out;
2762                 }
2763                 tsp = smack_cred(new);
2764                 smk_destroy_label_list(&tsp->smk_relabel);
2765                 list_splice(&list_tmp, &tsp->smk_relabel);
2766                 commit_creds(new);
2767                 return count;
2768         }
2769 out:
2770         smk_destroy_label_list(&list_tmp);
2771         return rc;
2772 }
2773
2774 static const struct file_operations smk_relabel_self_ops = {
2775         .open           = smk_open_relabel_self,
2776         .read           = seq_read,
2777         .llseek         = seq_lseek,
2778         .write          = smk_write_relabel_self,
2779         .release        = seq_release,
2780 };
2781
2782 /**
2783  * smk_read_ptrace - read() for /smack/ptrace
2784  * @filp: file pointer, not actually used
2785  * @buf: where to put the result
2786  * @count: maximum to send along
2787  * @ppos: where to start
2788  *
2789  * Returns number of bytes read or error code, as appropriate
2790  */
2791 static ssize_t smk_read_ptrace(struct file *filp, char __user *buf,
2792                                size_t count, loff_t *ppos)
2793 {
2794         char temp[32];
2795         ssize_t rc;
2796
2797         if (*ppos != 0)
2798                 return 0;
2799
2800         sprintf(temp, "%d\n", smack_ptrace_rule);
2801         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2802         return rc;
2803 }
2804
2805 /**
2806  * smk_write_ptrace - write() for /smack/ptrace
2807  * @file: file pointer
2808  * @buf: data from user space
2809  * @count: bytes sent
2810  * @ppos: where to start - must be 0
2811  */
2812 static ssize_t smk_write_ptrace(struct file *file, const char __user *buf,
2813                                 size_t count, loff_t *ppos)
2814 {
2815         char temp[32];
2816         int i;
2817
2818         if (!smack_privileged(CAP_MAC_ADMIN))
2819                 return -EPERM;
2820
2821         if (*ppos != 0 || count >= sizeof(temp) || count == 0)
2822                 return -EINVAL;
2823
2824         if (copy_from_user(temp, buf, count) != 0)
2825                 return -EFAULT;
2826
2827         temp[count] = '\0';
2828
2829         if (sscanf(temp, "%d", &i) != 1)
2830                 return -EINVAL;
2831         if (i < SMACK_PTRACE_DEFAULT || i > SMACK_PTRACE_MAX)
2832                 return -EINVAL;
2833         smack_ptrace_rule = i;
2834
2835         return count;
2836 }
2837
2838 static const struct file_operations smk_ptrace_ops = {
2839         .write          = smk_write_ptrace,
2840         .read           = smk_read_ptrace,
2841         .llseek         = default_llseek,
2842 };
2843
2844 /**
2845  * smk_fill_super - fill the smackfs superblock
2846  * @sb: the empty superblock
2847  * @fc: unused
2848  *
2849  * Fill in the well known entries for the smack filesystem
2850  *
2851  * Returns 0 on success, an error code on failure
2852  */
2853 static int smk_fill_super(struct super_block *sb, struct fs_context *fc)
2854 {
2855         int rc;
2856
2857         static const struct tree_descr smack_files[] = {
2858                 [SMK_LOAD] = {
2859                         "load", &smk_load_ops, S_IRUGO|S_IWUSR},
2860                 [SMK_CIPSO] = {
2861                         "cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
2862                 [SMK_DOI] = {
2863                         "doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
2864                 [SMK_DIRECT] = {
2865                         "direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
2866                 [SMK_AMBIENT] = {
2867                         "ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
2868                 [SMK_NET4ADDR] = {
2869                         "netlabel", &smk_net4addr_ops, S_IRUGO|S_IWUSR},
2870                 [SMK_ONLYCAP] = {
2871                         "onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
2872                 [SMK_LOGGING] = {
2873                         "logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
2874                 [SMK_LOAD_SELF] = {
2875                         "load-self", &smk_load_self_ops, S_IRUGO|S_IWUGO},
2876                 [SMK_ACCESSES] = {
2877                         "access", &smk_access_ops, S_IRUGO|S_IWUGO},
2878                 [SMK_MAPPED] = {
2879                         "mapped", &smk_mapped_ops, S_IRUGO|S_IWUSR},
2880                 [SMK_LOAD2] = {
2881                         "load2", &smk_load2_ops, S_IRUGO|S_IWUSR},
2882                 [SMK_LOAD_SELF2] = {
2883                         "load-self2", &smk_load_self2_ops, S_IRUGO|S_IWUGO},
2884                 [SMK_ACCESS2] = {
2885                         "access2", &smk_access2_ops, S_IRUGO|S_IWUGO},
2886                 [SMK_CIPSO2] = {
2887                         "cipso2", &smk_cipso2_ops, S_IRUGO|S_IWUSR},
2888                 [SMK_REVOKE_SUBJ] = {
2889                         "revoke-subject", &smk_revoke_subj_ops,
2890                         S_IRUGO|S_IWUSR},
2891                 [SMK_CHANGE_RULE] = {
2892                         "change-rule", &smk_change_rule_ops, S_IRUGO|S_IWUSR},
2893                 [SMK_SYSLOG] = {
2894                         "syslog", &smk_syslog_ops, S_IRUGO|S_IWUSR},
2895                 [SMK_PTRACE] = {
2896                         "ptrace", &smk_ptrace_ops, S_IRUGO|S_IWUSR},
2897 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
2898                 [SMK_UNCONFINED] = {
2899                         "unconfined", &smk_unconfined_ops, S_IRUGO|S_IWUSR},
2900 #endif
2901 #if IS_ENABLED(CONFIG_IPV6)
2902                 [SMK_NET6ADDR] = {
2903                         "ipv6host", &smk_net6addr_ops, S_IRUGO|S_IWUSR},
2904 #endif /* CONFIG_IPV6 */
2905                 [SMK_RELABEL_SELF] = {
2906                         "relabel-self", &smk_relabel_self_ops,
2907                                 S_IRUGO|S_IWUGO},
2908                 /* last one */
2909                         {""}
2910         };
2911
2912         rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
2913         if (rc != 0) {
2914                 printk(KERN_ERR "%s failed %d while creating inodes\n",
2915                         __func__, rc);
2916                 return rc;
2917         }
2918
2919         return 0;
2920 }
2921
2922 /**
2923  * smk_get_tree - get the smackfs superblock
2924  * @fc: The mount context, including any options
2925  *
2926  * Just passes everything along.
2927  *
2928  * Returns what the lower level code does.
2929  */
2930 static int smk_get_tree(struct fs_context *fc)
2931 {
2932         return get_tree_single(fc, smk_fill_super);
2933 }
2934
2935 static const struct fs_context_operations smk_context_ops = {
2936         .get_tree       = smk_get_tree,
2937 };
2938
2939 /**
2940  * smk_init_fs_context - Initialise a filesystem context for smackfs
2941  * @fc: The blank mount context
2942  */
2943 static int smk_init_fs_context(struct fs_context *fc)
2944 {
2945         fc->ops = &smk_context_ops;
2946         return 0;
2947 }
2948
2949 static struct file_system_type smk_fs_type = {
2950         .name           = "smackfs",
2951         .init_fs_context = smk_init_fs_context,
2952         .kill_sb        = kill_litter_super,
2953 };
2954
2955 static struct vfsmount *smackfs_mount;
2956
2957 /**
2958  * init_smk_fs - get the smackfs superblock
2959  *
2960  * register the smackfs
2961  *
2962  * Do not register smackfs if Smack wasn't enabled
2963  * on boot. We can not put this method normally under the
2964  * smack_init() code path since the security subsystem get
2965  * initialized before the vfs caches.
2966  *
2967  * Returns true if we were not chosen on boot or if
2968  * we were chosen and filesystem registration succeeded.
2969  */
2970 static int __init init_smk_fs(void)
2971 {
2972         int err;
2973         int rc;
2974
2975         if (smack_enabled == 0)
2976                 return 0;
2977
2978         err = smk_init_sysfs();
2979         if (err)
2980                 printk(KERN_ERR "smackfs: sysfs mountpoint problem.\n");
2981
2982         err = register_filesystem(&smk_fs_type);
2983         if (!err) {
2984                 smackfs_mount = kern_mount(&smk_fs_type);
2985                 if (IS_ERR(smackfs_mount)) {
2986                         printk(KERN_ERR "smackfs:  could not mount!\n");
2987                         err = PTR_ERR(smackfs_mount);
2988                         smackfs_mount = NULL;
2989                 }
2990         }
2991
2992         smk_cipso_doi();
2993         smk_unlbl_ambient(NULL);
2994
2995         rc = smack_populate_secattr(&smack_known_floor);
2996         if (err == 0 && rc < 0)
2997                 err = rc;
2998         rc = smack_populate_secattr(&smack_known_hat);
2999         if (err == 0 && rc < 0)
3000                 err = rc;
3001         rc = smack_populate_secattr(&smack_known_huh);
3002         if (err == 0 && rc < 0)
3003                 err = rc;
3004         rc = smack_populate_secattr(&smack_known_star);
3005         if (err == 0 && rc < 0)
3006                 err = rc;
3007         rc = smack_populate_secattr(&smack_known_web);
3008         if (err == 0 && rc < 0)
3009                 err = rc;
3010
3011         return err;
3012 }
3013
3014 __initcall(init_smk_fs);