xref: /openbmc/linux/security/smack/smackfs.c (revision 29c37341)
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 
927 out:
928 	mutex_unlock(&smack_cipso_lock);
929 	kfree(data);
930 	return rc;
931 }
932 
933 /**
934  * smk_write_cipso - write() for /smack/cipso
935  * @file: file pointer, not actually used
936  * @buf: where to get the data from
937  * @count: bytes sent
938  * @ppos: where to start
939  *
940  * Accepts only one cipso rule per write call.
941  * Returns number of bytes written or error code, as appropriate
942  */
943 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
944 			       size_t count, loff_t *ppos)
945 {
946 	return smk_set_cipso(file, buf, count, ppos, SMK_FIXED24_FMT);
947 }
948 
949 static const struct file_operations smk_cipso_ops = {
950 	.open           = smk_open_cipso,
951 	.read		= seq_read,
952 	.llseek         = seq_lseek,
953 	.write		= smk_write_cipso,
954 	.release        = seq_release,
955 };
956 
957 /*
958  * Seq_file read operations for /smack/cipso2
959  */
960 
961 /*
962  * Print cipso labels in format:
963  * label level[/cat[,cat]]
964  */
965 static int cipso2_seq_show(struct seq_file *s, void *v)
966 {
967 	struct list_head  *list = v;
968 	struct smack_known *skp =
969 		list_entry_rcu(list, struct smack_known, list);
970 	struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
971 	char sep = '/';
972 	int i;
973 
974 	seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
975 
976 	for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
977 	     i = netlbl_catmap_walk(cmp, i + 1)) {
978 		seq_printf(s, "%c%d", sep, i);
979 		sep = ',';
980 	}
981 
982 	seq_putc(s, '\n');
983 
984 	return 0;
985 }
986 
987 static const struct seq_operations cipso2_seq_ops = {
988 	.start = cipso_seq_start,
989 	.next  = cipso_seq_next,
990 	.show  = cipso2_seq_show,
991 	.stop  = smk_seq_stop,
992 };
993 
994 /**
995  * smk_open_cipso2 - open() for /smack/cipso2
996  * @inode: inode structure representing file
997  * @file: "cipso2" file pointer
998  *
999  * Connect our cipso_seq_* operations with /smack/cipso2
1000  * file_operations
1001  */
1002 static int smk_open_cipso2(struct inode *inode, struct file *file)
1003 {
1004 	return seq_open(file, &cipso2_seq_ops);
1005 }
1006 
1007 /**
1008  * smk_write_cipso2 - write() for /smack/cipso2
1009  * @file: file pointer, not actually used
1010  * @buf: where to get the data from
1011  * @count: bytes sent
1012  * @ppos: where to start
1013  *
1014  * Accepts only one cipso rule per write call.
1015  * Returns number of bytes written or error code, as appropriate
1016  */
1017 static ssize_t smk_write_cipso2(struct file *file, const char __user *buf,
1018 			      size_t count, loff_t *ppos)
1019 {
1020 	return smk_set_cipso(file, buf, count, ppos, SMK_LONG_FMT);
1021 }
1022 
1023 static const struct file_operations smk_cipso2_ops = {
1024 	.open           = smk_open_cipso2,
1025 	.read		= seq_read,
1026 	.llseek         = seq_lseek,
1027 	.write		= smk_write_cipso2,
1028 	.release        = seq_release,
1029 };
1030 
1031 /*
1032  * Seq_file read operations for /smack/netlabel
1033  */
1034 
1035 static void *net4addr_seq_start(struct seq_file *s, loff_t *pos)
1036 {
1037 	return smk_seq_start(s, pos, &smk_net4addr_list);
1038 }
1039 
1040 static void *net4addr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1041 {
1042 	return smk_seq_next(s, v, pos, &smk_net4addr_list);
1043 }
1044 
1045 /*
1046  * Print host/label pairs
1047  */
1048 static int net4addr_seq_show(struct seq_file *s, void *v)
1049 {
1050 	struct list_head *list = v;
1051 	struct smk_net4addr *skp =
1052 			list_entry_rcu(list, struct smk_net4addr, list);
1053 	char *kp = SMACK_CIPSO_OPTION;
1054 
1055 	if (skp->smk_label != NULL)
1056 		kp = skp->smk_label->smk_known;
1057 	seq_printf(s, "%pI4/%d %s\n", &skp->smk_host.s_addr,
1058 			skp->smk_masks, kp);
1059 
1060 	return 0;
1061 }
1062 
1063 static const struct seq_operations net4addr_seq_ops = {
1064 	.start = net4addr_seq_start,
1065 	.next  = net4addr_seq_next,
1066 	.show  = net4addr_seq_show,
1067 	.stop  = smk_seq_stop,
1068 };
1069 
1070 /**
1071  * smk_open_net4addr - open() for /smack/netlabel
1072  * @inode: inode structure representing file
1073  * @file: "netlabel" file pointer
1074  *
1075  * Connect our net4addr_seq_* operations with /smack/netlabel
1076  * file_operations
1077  */
1078 static int smk_open_net4addr(struct inode *inode, struct file *file)
1079 {
1080 	return seq_open(file, &net4addr_seq_ops);
1081 }
1082 
1083 /**
1084  * smk_net4addr_insert
1085  * @new : netlabel to insert
1086  *
1087  * This helper insert netlabel in the smack_net4addrs list
1088  * sorted by netmask length (longest to smallest)
1089  * locked by &smk_net4addr_lock in smk_write_net4addr
1090  *
1091  */
1092 static void smk_net4addr_insert(struct smk_net4addr *new)
1093 {
1094 	struct smk_net4addr *m;
1095 	struct smk_net4addr *m_next;
1096 
1097 	if (list_empty(&smk_net4addr_list)) {
1098 		list_add_rcu(&new->list, &smk_net4addr_list);
1099 		return;
1100 	}
1101 
1102 	m = list_entry_rcu(smk_net4addr_list.next,
1103 			   struct smk_net4addr, list);
1104 
1105 	/* the comparison '>' is a bit hacky, but works */
1106 	if (new->smk_masks > m->smk_masks) {
1107 		list_add_rcu(&new->list, &smk_net4addr_list);
1108 		return;
1109 	}
1110 
1111 	list_for_each_entry_rcu(m, &smk_net4addr_list, list) {
1112 		if (list_is_last(&m->list, &smk_net4addr_list)) {
1113 			list_add_rcu(&new->list, &m->list);
1114 			return;
1115 		}
1116 		m_next = list_entry_rcu(m->list.next,
1117 					struct smk_net4addr, list);
1118 		if (new->smk_masks > m_next->smk_masks) {
1119 			list_add_rcu(&new->list, &m->list);
1120 			return;
1121 		}
1122 	}
1123 }
1124 
1125 
1126 /**
1127  * smk_write_net4addr - write() for /smack/netlabel
1128  * @file: file pointer, not actually used
1129  * @buf: where to get the data from
1130  * @count: bytes sent
1131  * @ppos: where to start
1132  *
1133  * Accepts only one net4addr per write call.
1134  * Returns number of bytes written or error code, as appropriate
1135  */
1136 static ssize_t smk_write_net4addr(struct file *file, const char __user *buf,
1137 				size_t count, loff_t *ppos)
1138 {
1139 	struct smk_net4addr *snp;
1140 	struct sockaddr_in newname;
1141 	char *smack;
1142 	struct smack_known *skp = NULL;
1143 	char *data;
1144 	char *host = (char *)&newname.sin_addr.s_addr;
1145 	int rc;
1146 	struct netlbl_audit audit_info;
1147 	struct in_addr mask;
1148 	unsigned int m;
1149 	unsigned int masks;
1150 	int found;
1151 	u32 mask_bits = (1<<31);
1152 	__be32 nsa;
1153 	u32 temp_mask;
1154 
1155 	/*
1156 	 * Must have privilege.
1157 	 * No partial writes.
1158 	 * Enough data must be present.
1159 	 * "<addr/mask, as a.b.c.d/e><space><label>"
1160 	 * "<addr, as a.b.c.d><space><label>"
1161 	 */
1162 	if (!smack_privileged(CAP_MAC_ADMIN))
1163 		return -EPERM;
1164 	if (*ppos != 0)
1165 		return -EINVAL;
1166 	if (count < SMK_NETLBLADDRMIN)
1167 		return -EINVAL;
1168 
1169 	data = memdup_user_nul(buf, count);
1170 	if (IS_ERR(data))
1171 		return PTR_ERR(data);
1172 
1173 	smack = kzalloc(count + 1, GFP_KERNEL);
1174 	if (smack == NULL) {
1175 		rc = -ENOMEM;
1176 		goto free_data_out;
1177 	}
1178 
1179 	rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd/%u %s",
1180 		&host[0], &host[1], &host[2], &host[3], &masks, smack);
1181 	if (rc != 6) {
1182 		rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
1183 			&host[0], &host[1], &host[2], &host[3], smack);
1184 		if (rc != 5) {
1185 			rc = -EINVAL;
1186 			goto free_out;
1187 		}
1188 		m = BEBITS;
1189 		masks = 32;
1190 	}
1191 	if (masks > BEBITS) {
1192 		rc = -EINVAL;
1193 		goto free_out;
1194 	}
1195 
1196 	/*
1197 	 * If smack begins with '-', it is an option, don't import it
1198 	 */
1199 	if (smack[0] != '-') {
1200 		skp = smk_import_entry(smack, 0);
1201 		if (IS_ERR(skp)) {
1202 			rc = PTR_ERR(skp);
1203 			goto free_out;
1204 		}
1205 	} else {
1206 		/*
1207 		 * Only the -CIPSO option is supported for IPv4
1208 		 */
1209 		if (strcmp(smack, SMACK_CIPSO_OPTION) != 0) {
1210 			rc = -EINVAL;
1211 			goto free_out;
1212 		}
1213 	}
1214 
1215 	for (m = masks, temp_mask = 0; m > 0; m--) {
1216 		temp_mask |= mask_bits;
1217 		mask_bits >>= 1;
1218 	}
1219 	mask.s_addr = cpu_to_be32(temp_mask);
1220 
1221 	newname.sin_addr.s_addr &= mask.s_addr;
1222 	/*
1223 	 * Only allow one writer at a time. Writes should be
1224 	 * quite rare and small in any case.
1225 	 */
1226 	mutex_lock(&smk_net4addr_lock);
1227 
1228 	nsa = newname.sin_addr.s_addr;
1229 	/* try to find if the prefix is already in the list */
1230 	found = 0;
1231 	list_for_each_entry_rcu(snp, &smk_net4addr_list, list) {
1232 		if (snp->smk_host.s_addr == nsa && snp->smk_masks == masks) {
1233 			found = 1;
1234 			break;
1235 		}
1236 	}
1237 	smk_netlabel_audit_set(&audit_info);
1238 
1239 	if (found == 0) {
1240 		snp = kzalloc(sizeof(*snp), GFP_KERNEL);
1241 		if (snp == NULL)
1242 			rc = -ENOMEM;
1243 		else {
1244 			rc = 0;
1245 			snp->smk_host.s_addr = newname.sin_addr.s_addr;
1246 			snp->smk_mask.s_addr = mask.s_addr;
1247 			snp->smk_label = skp;
1248 			snp->smk_masks = masks;
1249 			smk_net4addr_insert(snp);
1250 		}
1251 	} else {
1252 		/*
1253 		 * Delete the unlabeled entry, only if the previous label
1254 		 * wasn't the special CIPSO option
1255 		 */
1256 		if (snp->smk_label != NULL)
1257 			rc = netlbl_cfg_unlbl_static_del(&init_net, NULL,
1258 					&snp->smk_host, &snp->smk_mask,
1259 					PF_INET, &audit_info);
1260 		else
1261 			rc = 0;
1262 		snp->smk_label = skp;
1263 	}
1264 
1265 	/*
1266 	 * Now tell netlabel about the single label nature of
1267 	 * this host so that incoming packets get labeled.
1268 	 * but only if we didn't get the special CIPSO option
1269 	 */
1270 	if (rc == 0 && skp != NULL)
1271 		rc = netlbl_cfg_unlbl_static_add(&init_net, NULL,
1272 			&snp->smk_host, &snp->smk_mask, PF_INET,
1273 			snp->smk_label->smk_secid, &audit_info);
1274 
1275 	if (rc == 0)
1276 		rc = count;
1277 
1278 	mutex_unlock(&smk_net4addr_lock);
1279 
1280 free_out:
1281 	kfree(smack);
1282 free_data_out:
1283 	kfree(data);
1284 
1285 	return rc;
1286 }
1287 
1288 static const struct file_operations smk_net4addr_ops = {
1289 	.open           = smk_open_net4addr,
1290 	.read		= seq_read,
1291 	.llseek         = seq_lseek,
1292 	.write		= smk_write_net4addr,
1293 	.release        = seq_release,
1294 };
1295 
1296 #if IS_ENABLED(CONFIG_IPV6)
1297 /*
1298  * Seq_file read operations for /smack/netlabel6
1299  */
1300 
1301 static void *net6addr_seq_start(struct seq_file *s, loff_t *pos)
1302 {
1303 	return smk_seq_start(s, pos, &smk_net6addr_list);
1304 }
1305 
1306 static void *net6addr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1307 {
1308 	return smk_seq_next(s, v, pos, &smk_net6addr_list);
1309 }
1310 
1311 /*
1312  * Print host/label pairs
1313  */
1314 static int net6addr_seq_show(struct seq_file *s, void *v)
1315 {
1316 	struct list_head *list = v;
1317 	struct smk_net6addr *skp =
1318 			 list_entry(list, struct smk_net6addr, list);
1319 
1320 	if (skp->smk_label != NULL)
1321 		seq_printf(s, "%pI6/%d %s\n", &skp->smk_host, skp->smk_masks,
1322 				skp->smk_label->smk_known);
1323 
1324 	return 0;
1325 }
1326 
1327 static const struct seq_operations net6addr_seq_ops = {
1328 	.start = net6addr_seq_start,
1329 	.next  = net6addr_seq_next,
1330 	.show  = net6addr_seq_show,
1331 	.stop  = smk_seq_stop,
1332 };
1333 
1334 /**
1335  * smk_open_net6addr - open() for /smack/netlabel
1336  * @inode: inode structure representing file
1337  * @file: "netlabel" file pointer
1338  *
1339  * Connect our net6addr_seq_* operations with /smack/netlabel
1340  * file_operations
1341  */
1342 static int smk_open_net6addr(struct inode *inode, struct file *file)
1343 {
1344 	return seq_open(file, &net6addr_seq_ops);
1345 }
1346 
1347 /**
1348  * smk_net6addr_insert
1349  * @new : entry to insert
1350  *
1351  * This inserts an entry in the smack_net6addrs list
1352  * sorted by netmask length (longest to smallest)
1353  * locked by &smk_net6addr_lock in smk_write_net6addr
1354  *
1355  */
1356 static void smk_net6addr_insert(struct smk_net6addr *new)
1357 {
1358 	struct smk_net6addr *m_next;
1359 	struct smk_net6addr *m;
1360 
1361 	if (list_empty(&smk_net6addr_list)) {
1362 		list_add_rcu(&new->list, &smk_net6addr_list);
1363 		return;
1364 	}
1365 
1366 	m = list_entry_rcu(smk_net6addr_list.next,
1367 			   struct smk_net6addr, list);
1368 
1369 	if (new->smk_masks > m->smk_masks) {
1370 		list_add_rcu(&new->list, &smk_net6addr_list);
1371 		return;
1372 	}
1373 
1374 	list_for_each_entry_rcu(m, &smk_net6addr_list, list) {
1375 		if (list_is_last(&m->list, &smk_net6addr_list)) {
1376 			list_add_rcu(&new->list, &m->list);
1377 			return;
1378 		}
1379 		m_next = list_entry_rcu(m->list.next,
1380 					struct smk_net6addr, list);
1381 		if (new->smk_masks > m_next->smk_masks) {
1382 			list_add_rcu(&new->list, &m->list);
1383 			return;
1384 		}
1385 	}
1386 }
1387 
1388 
1389 /**
1390  * smk_write_net6addr - write() for /smack/netlabel
1391  * @file: file pointer, not actually used
1392  * @buf: where to get the data from
1393  * @count: bytes sent
1394  * @ppos: where to start
1395  *
1396  * Accepts only one net6addr per write call.
1397  * Returns number of bytes written or error code, as appropriate
1398  */
1399 static ssize_t smk_write_net6addr(struct file *file, const char __user *buf,
1400 				size_t count, loff_t *ppos)
1401 {
1402 	struct smk_net6addr *snp;
1403 	struct in6_addr newname;
1404 	struct in6_addr fullmask;
1405 	struct smack_known *skp = NULL;
1406 	char *smack;
1407 	char *data;
1408 	int rc = 0;
1409 	int found = 0;
1410 	int i;
1411 	unsigned int scanned[8];
1412 	unsigned int m;
1413 	unsigned int mask = 128;
1414 
1415 	/*
1416 	 * Must have privilege.
1417 	 * No partial writes.
1418 	 * Enough data must be present.
1419 	 * "<addr/mask, as a:b:c:d:e:f:g:h/e><space><label>"
1420 	 * "<addr, as a:b:c:d:e:f:g:h><space><label>"
1421 	 */
1422 	if (!smack_privileged(CAP_MAC_ADMIN))
1423 		return -EPERM;
1424 	if (*ppos != 0)
1425 		return -EINVAL;
1426 	if (count < SMK_NETLBLADDRMIN)
1427 		return -EINVAL;
1428 
1429 	data = memdup_user_nul(buf, count);
1430 	if (IS_ERR(data))
1431 		return PTR_ERR(data);
1432 
1433 	smack = kzalloc(count + 1, GFP_KERNEL);
1434 	if (smack == NULL) {
1435 		rc = -ENOMEM;
1436 		goto free_data_out;
1437 	}
1438 
1439 	i = sscanf(data, "%x:%x:%x:%x:%x:%x:%x:%x/%u %s",
1440 			&scanned[0], &scanned[1], &scanned[2], &scanned[3],
1441 			&scanned[4], &scanned[5], &scanned[6], &scanned[7],
1442 			&mask, smack);
1443 	if (i != 10) {
1444 		i = sscanf(data, "%x:%x:%x:%x:%x:%x:%x:%x %s",
1445 				&scanned[0], &scanned[1], &scanned[2],
1446 				&scanned[3], &scanned[4], &scanned[5],
1447 				&scanned[6], &scanned[7], smack);
1448 		if (i != 9) {
1449 			rc = -EINVAL;
1450 			goto free_out;
1451 		}
1452 	}
1453 	if (mask > 128) {
1454 		rc = -EINVAL;
1455 		goto free_out;
1456 	}
1457 	for (i = 0; i < 8; i++) {
1458 		if (scanned[i] > 0xffff) {
1459 			rc = -EINVAL;
1460 			goto free_out;
1461 		}
1462 		newname.s6_addr16[i] = htons(scanned[i]);
1463 	}
1464 
1465 	/*
1466 	 * If smack begins with '-', it is an option, don't import it
1467 	 */
1468 	if (smack[0] != '-') {
1469 		skp = smk_import_entry(smack, 0);
1470 		if (IS_ERR(skp)) {
1471 			rc = PTR_ERR(skp);
1472 			goto free_out;
1473 		}
1474 	} else {
1475 		/*
1476 		 * Only -DELETE is supported for IPv6
1477 		 */
1478 		if (strcmp(smack, SMACK_DELETE_OPTION) != 0) {
1479 			rc = -EINVAL;
1480 			goto free_out;
1481 		}
1482 	}
1483 
1484 	for (i = 0, m = mask; i < 8; i++) {
1485 		if (m >= 16) {
1486 			fullmask.s6_addr16[i] = 0xffff;
1487 			m -= 16;
1488 		} else if (m > 0) {
1489 			fullmask.s6_addr16[i] = (1 << m) - 1;
1490 			m = 0;
1491 		} else
1492 			fullmask.s6_addr16[i] = 0;
1493 		newname.s6_addr16[i] &= fullmask.s6_addr16[i];
1494 	}
1495 
1496 	/*
1497 	 * Only allow one writer at a time. Writes should be
1498 	 * quite rare and small in any case.
1499 	 */
1500 	mutex_lock(&smk_net6addr_lock);
1501 	/*
1502 	 * Try to find the prefix in the list
1503 	 */
1504 	list_for_each_entry_rcu(snp, &smk_net6addr_list, list) {
1505 		if (mask != snp->smk_masks)
1506 			continue;
1507 		for (found = 1, i = 0; i < 8; i++) {
1508 			if (newname.s6_addr16[i] !=
1509 			    snp->smk_host.s6_addr16[i]) {
1510 				found = 0;
1511 				break;
1512 			}
1513 		}
1514 		if (found == 1)
1515 			break;
1516 	}
1517 	if (found == 0) {
1518 		snp = kzalloc(sizeof(*snp), GFP_KERNEL);
1519 		if (snp == NULL)
1520 			rc = -ENOMEM;
1521 		else {
1522 			snp->smk_host = newname;
1523 			snp->smk_mask = fullmask;
1524 			snp->smk_masks = mask;
1525 			snp->smk_label = skp;
1526 			smk_net6addr_insert(snp);
1527 		}
1528 	} else {
1529 		snp->smk_label = skp;
1530 	}
1531 
1532 	if (rc == 0)
1533 		rc = count;
1534 
1535 	mutex_unlock(&smk_net6addr_lock);
1536 
1537 free_out:
1538 	kfree(smack);
1539 free_data_out:
1540 	kfree(data);
1541 
1542 	return rc;
1543 }
1544 
1545 static const struct file_operations smk_net6addr_ops = {
1546 	.open           = smk_open_net6addr,
1547 	.read		= seq_read,
1548 	.llseek         = seq_lseek,
1549 	.write		= smk_write_net6addr,
1550 	.release        = seq_release,
1551 };
1552 #endif /* CONFIG_IPV6 */
1553 
1554 /**
1555  * smk_read_doi - read() for /smack/doi
1556  * @filp: file pointer, not actually used
1557  * @buf: where to put the result
1558  * @count: maximum to send along
1559  * @ppos: where to start
1560  *
1561  * Returns number of bytes read or error code, as appropriate
1562  */
1563 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
1564 			    size_t count, loff_t *ppos)
1565 {
1566 	char temp[80];
1567 	ssize_t rc;
1568 
1569 	if (*ppos != 0)
1570 		return 0;
1571 
1572 	sprintf(temp, "%d", smk_cipso_doi_value);
1573 	rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1574 
1575 	return rc;
1576 }
1577 
1578 /**
1579  * smk_write_doi - write() for /smack/doi
1580  * @file: file pointer, not actually used
1581  * @buf: where to get the data from
1582  * @count: bytes sent
1583  * @ppos: where to start
1584  *
1585  * Returns number of bytes written or error code, as appropriate
1586  */
1587 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
1588 			     size_t count, loff_t *ppos)
1589 {
1590 	char temp[80];
1591 	int i;
1592 
1593 	if (!smack_privileged(CAP_MAC_ADMIN))
1594 		return -EPERM;
1595 
1596 	if (count >= sizeof(temp) || count == 0)
1597 		return -EINVAL;
1598 
1599 	if (copy_from_user(temp, buf, count) != 0)
1600 		return -EFAULT;
1601 
1602 	temp[count] = '\0';
1603 
1604 	if (sscanf(temp, "%d", &i) != 1)
1605 		return -EINVAL;
1606 
1607 	smk_cipso_doi_value = i;
1608 
1609 	smk_cipso_doi();
1610 
1611 	return count;
1612 }
1613 
1614 static const struct file_operations smk_doi_ops = {
1615 	.read		= smk_read_doi,
1616 	.write		= smk_write_doi,
1617 	.llseek		= default_llseek,
1618 };
1619 
1620 /**
1621  * smk_read_direct - read() for /smack/direct
1622  * @filp: file pointer, not actually used
1623  * @buf: where to put the result
1624  * @count: maximum to send along
1625  * @ppos: where to start
1626  *
1627  * Returns number of bytes read or error code, as appropriate
1628  */
1629 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
1630 			       size_t count, loff_t *ppos)
1631 {
1632 	char temp[80];
1633 	ssize_t rc;
1634 
1635 	if (*ppos != 0)
1636 		return 0;
1637 
1638 	sprintf(temp, "%d", smack_cipso_direct);
1639 	rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1640 
1641 	return rc;
1642 }
1643 
1644 /**
1645  * smk_write_direct - write() for /smack/direct
1646  * @file: file pointer, not actually used
1647  * @buf: where to get the data from
1648  * @count: bytes sent
1649  * @ppos: where to start
1650  *
1651  * Returns number of bytes written or error code, as appropriate
1652  */
1653 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
1654 				size_t count, loff_t *ppos)
1655 {
1656 	struct smack_known *skp;
1657 	char temp[80];
1658 	int i;
1659 
1660 	if (!smack_privileged(CAP_MAC_ADMIN))
1661 		return -EPERM;
1662 
1663 	if (count >= sizeof(temp) || count == 0)
1664 		return -EINVAL;
1665 
1666 	if (copy_from_user(temp, buf, count) != 0)
1667 		return -EFAULT;
1668 
1669 	temp[count] = '\0';
1670 
1671 	if (sscanf(temp, "%d", &i) != 1)
1672 		return -EINVAL;
1673 
1674 	/*
1675 	 * Don't do anything if the value hasn't actually changed.
1676 	 * If it is changing reset the level on entries that were
1677 	 * set up to be direct when they were created.
1678 	 */
1679 	if (smack_cipso_direct != i) {
1680 		mutex_lock(&smack_known_lock);
1681 		list_for_each_entry_rcu(skp, &smack_known_list, list)
1682 			if (skp->smk_netlabel.attr.mls.lvl ==
1683 			    smack_cipso_direct)
1684 				skp->smk_netlabel.attr.mls.lvl = i;
1685 		smack_cipso_direct = i;
1686 		mutex_unlock(&smack_known_lock);
1687 	}
1688 
1689 	return count;
1690 }
1691 
1692 static const struct file_operations smk_direct_ops = {
1693 	.read		= smk_read_direct,
1694 	.write		= smk_write_direct,
1695 	.llseek		= default_llseek,
1696 };
1697 
1698 /**
1699  * smk_read_mapped - read() for /smack/mapped
1700  * @filp: file pointer, not actually used
1701  * @buf: where to put the result
1702  * @count: maximum to send along
1703  * @ppos: where to start
1704  *
1705  * Returns number of bytes read or error code, as appropriate
1706  */
1707 static ssize_t smk_read_mapped(struct file *filp, char __user *buf,
1708 			       size_t count, loff_t *ppos)
1709 {
1710 	char temp[80];
1711 	ssize_t rc;
1712 
1713 	if (*ppos != 0)
1714 		return 0;
1715 
1716 	sprintf(temp, "%d", smack_cipso_mapped);
1717 	rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1718 
1719 	return rc;
1720 }
1721 
1722 /**
1723  * smk_write_mapped - write() for /smack/mapped
1724  * @file: file pointer, not actually used
1725  * @buf: where to get the data from
1726  * @count: bytes sent
1727  * @ppos: where to start
1728  *
1729  * Returns number of bytes written or error code, as appropriate
1730  */
1731 static ssize_t smk_write_mapped(struct file *file, const char __user *buf,
1732 				size_t count, loff_t *ppos)
1733 {
1734 	struct smack_known *skp;
1735 	char temp[80];
1736 	int i;
1737 
1738 	if (!smack_privileged(CAP_MAC_ADMIN))
1739 		return -EPERM;
1740 
1741 	if (count >= sizeof(temp) || count == 0)
1742 		return -EINVAL;
1743 
1744 	if (copy_from_user(temp, buf, count) != 0)
1745 		return -EFAULT;
1746 
1747 	temp[count] = '\0';
1748 
1749 	if (sscanf(temp, "%d", &i) != 1)
1750 		return -EINVAL;
1751 
1752 	/*
1753 	 * Don't do anything if the value hasn't actually changed.
1754 	 * If it is changing reset the level on entries that were
1755 	 * set up to be mapped when they were created.
1756 	 */
1757 	if (smack_cipso_mapped != i) {
1758 		mutex_lock(&smack_known_lock);
1759 		list_for_each_entry_rcu(skp, &smack_known_list, list)
1760 			if (skp->smk_netlabel.attr.mls.lvl ==
1761 			    smack_cipso_mapped)
1762 				skp->smk_netlabel.attr.mls.lvl = i;
1763 		smack_cipso_mapped = i;
1764 		mutex_unlock(&smack_known_lock);
1765 	}
1766 
1767 	return count;
1768 }
1769 
1770 static const struct file_operations smk_mapped_ops = {
1771 	.read		= smk_read_mapped,
1772 	.write		= smk_write_mapped,
1773 	.llseek		= default_llseek,
1774 };
1775 
1776 /**
1777  * smk_read_ambient - read() for /smack/ambient
1778  * @filp: file pointer, not actually used
1779  * @buf: where to put the result
1780  * @cn: maximum to send along
1781  * @ppos: where to start
1782  *
1783  * Returns number of bytes read or error code, as appropriate
1784  */
1785 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
1786 				size_t cn, loff_t *ppos)
1787 {
1788 	ssize_t rc;
1789 	int asize;
1790 
1791 	if (*ppos != 0)
1792 		return 0;
1793 	/*
1794 	 * Being careful to avoid a problem in the case where
1795 	 * smack_net_ambient gets changed in midstream.
1796 	 */
1797 	mutex_lock(&smack_ambient_lock);
1798 
1799 	asize = strlen(smack_net_ambient->smk_known) + 1;
1800 
1801 	if (cn >= asize)
1802 		rc = simple_read_from_buffer(buf, cn, ppos,
1803 					     smack_net_ambient->smk_known,
1804 					     asize);
1805 	else
1806 		rc = -EINVAL;
1807 
1808 	mutex_unlock(&smack_ambient_lock);
1809 
1810 	return rc;
1811 }
1812 
1813 /**
1814  * smk_write_ambient - write() for /smack/ambient
1815  * @file: file pointer, not actually used
1816  * @buf: where to get the data from
1817  * @count: bytes sent
1818  * @ppos: where to start
1819  *
1820  * Returns number of bytes written or error code, as appropriate
1821  */
1822 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
1823 				 size_t count, loff_t *ppos)
1824 {
1825 	struct smack_known *skp;
1826 	char *oldambient;
1827 	char *data;
1828 	int rc = count;
1829 
1830 	if (!smack_privileged(CAP_MAC_ADMIN))
1831 		return -EPERM;
1832 
1833 	data = memdup_user_nul(buf, count);
1834 	if (IS_ERR(data))
1835 		return PTR_ERR(data);
1836 
1837 	skp = smk_import_entry(data, count);
1838 	if (IS_ERR(skp)) {
1839 		rc = PTR_ERR(skp);
1840 		goto out;
1841 	}
1842 
1843 	mutex_lock(&smack_ambient_lock);
1844 
1845 	oldambient = smack_net_ambient->smk_known;
1846 	smack_net_ambient = skp;
1847 	smk_unlbl_ambient(oldambient);
1848 
1849 	mutex_unlock(&smack_ambient_lock);
1850 
1851 out:
1852 	kfree(data);
1853 	return rc;
1854 }
1855 
1856 static const struct file_operations smk_ambient_ops = {
1857 	.read		= smk_read_ambient,
1858 	.write		= smk_write_ambient,
1859 	.llseek		= default_llseek,
1860 };
1861 
1862 /*
1863  * Seq_file operations for /smack/onlycap
1864  */
1865 static void *onlycap_seq_start(struct seq_file *s, loff_t *pos)
1866 {
1867 	return smk_seq_start(s, pos, &smack_onlycap_list);
1868 }
1869 
1870 static void *onlycap_seq_next(struct seq_file *s, void *v, loff_t *pos)
1871 {
1872 	return smk_seq_next(s, v, pos, &smack_onlycap_list);
1873 }
1874 
1875 static int onlycap_seq_show(struct seq_file *s, void *v)
1876 {
1877 	struct list_head *list = v;
1878 	struct smack_known_list_elem *sklep =
1879 		list_entry_rcu(list, struct smack_known_list_elem, list);
1880 
1881 	seq_puts(s, sklep->smk_label->smk_known);
1882 	seq_putc(s, ' ');
1883 
1884 	return 0;
1885 }
1886 
1887 static const struct seq_operations onlycap_seq_ops = {
1888 	.start = onlycap_seq_start,
1889 	.next  = onlycap_seq_next,
1890 	.show  = onlycap_seq_show,
1891 	.stop  = smk_seq_stop,
1892 };
1893 
1894 static int smk_open_onlycap(struct inode *inode, struct file *file)
1895 {
1896 	return seq_open(file, &onlycap_seq_ops);
1897 }
1898 
1899 /**
1900  * smk_list_swap_rcu - swap public list with a private one in RCU-safe way
1901  * The caller must hold appropriate mutex to prevent concurrent modifications
1902  * to the public list.
1903  * Private list is assumed to be not accessible to other threads yet.
1904  *
1905  * @public: public list
1906  * @private: private list
1907  */
1908 static void smk_list_swap_rcu(struct list_head *public,
1909 			      struct list_head *private)
1910 {
1911 	struct list_head *first, *last;
1912 
1913 	if (list_empty(public)) {
1914 		list_splice_init_rcu(private, public, synchronize_rcu);
1915 	} else {
1916 		/* Remember public list before replacing it */
1917 		first = public->next;
1918 		last = public->prev;
1919 
1920 		/* Publish private list in place of public in RCU-safe way */
1921 		private->prev->next = public;
1922 		private->next->prev = public;
1923 		rcu_assign_pointer(public->next, private->next);
1924 		public->prev = private->prev;
1925 
1926 		synchronize_rcu();
1927 
1928 		/* When all readers are done with the old public list,
1929 		 * attach it in place of private */
1930 		private->next = first;
1931 		private->prev = last;
1932 		first->prev = private;
1933 		last->next = private;
1934 	}
1935 }
1936 
1937 /**
1938  * smk_parse_label_list - parse list of Smack labels, separated by spaces
1939  *
1940  * @data: the string to parse
1941  * @private: destination list
1942  *
1943  * Returns zero on success or error code, as appropriate
1944  */
1945 static int smk_parse_label_list(char *data, struct list_head *list)
1946 {
1947 	char *tok;
1948 	struct smack_known *skp;
1949 	struct smack_known_list_elem *sklep;
1950 
1951 	while ((tok = strsep(&data, " ")) != NULL) {
1952 		if (!*tok)
1953 			continue;
1954 
1955 		skp = smk_import_entry(tok, 0);
1956 		if (IS_ERR(skp))
1957 			return PTR_ERR(skp);
1958 
1959 		sklep = kzalloc(sizeof(*sklep), GFP_KERNEL);
1960 		if (sklep == NULL)
1961 			return -ENOMEM;
1962 
1963 		sklep->smk_label = skp;
1964 		list_add(&sklep->list, list);
1965 	}
1966 
1967 	return 0;
1968 }
1969 
1970 /**
1971  * smk_destroy_label_list - destroy a list of smack_known_list_elem
1972  * @head: header pointer of the list to destroy
1973  */
1974 void smk_destroy_label_list(struct list_head *list)
1975 {
1976 	struct smack_known_list_elem *sklep;
1977 	struct smack_known_list_elem *sklep2;
1978 
1979 	list_for_each_entry_safe(sklep, sklep2, list, list)
1980 		kfree(sklep);
1981 
1982 	INIT_LIST_HEAD(list);
1983 }
1984 
1985 /**
1986  * smk_write_onlycap - write() for smackfs/onlycap
1987  * @file: file pointer, not actually used
1988  * @buf: where to get the data from
1989  * @count: bytes sent
1990  * @ppos: where to start
1991  *
1992  * Returns number of bytes written or error code, as appropriate
1993  */
1994 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
1995 				 size_t count, loff_t *ppos)
1996 {
1997 	char *data;
1998 	LIST_HEAD(list_tmp);
1999 	int rc;
2000 
2001 	if (!smack_privileged(CAP_MAC_ADMIN))
2002 		return -EPERM;
2003 
2004 	data = memdup_user_nul(buf, count);
2005 	if (IS_ERR(data))
2006 		return PTR_ERR(data);
2007 
2008 	rc = smk_parse_label_list(data, &list_tmp);
2009 	kfree(data);
2010 
2011 	/*
2012 	 * Clear the smack_onlycap on invalid label errors. This means
2013 	 * that we can pass a null string to unset the onlycap value.
2014 	 *
2015 	 * Importing will also reject a label beginning with '-',
2016 	 * so "-usecapabilities" will also work.
2017 	 *
2018 	 * But do so only on invalid label, not on system errors.
2019 	 * The invalid label must be first to count as clearing attempt.
2020 	 */
2021 	if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
2022 		mutex_lock(&smack_onlycap_lock);
2023 		smk_list_swap_rcu(&smack_onlycap_list, &list_tmp);
2024 		mutex_unlock(&smack_onlycap_lock);
2025 		rc = count;
2026 	}
2027 
2028 	smk_destroy_label_list(&list_tmp);
2029 
2030 	return rc;
2031 }
2032 
2033 static const struct file_operations smk_onlycap_ops = {
2034 	.open		= smk_open_onlycap,
2035 	.read		= seq_read,
2036 	.write		= smk_write_onlycap,
2037 	.llseek		= seq_lseek,
2038 	.release	= seq_release,
2039 };
2040 
2041 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
2042 /**
2043  * smk_read_unconfined - read() for smackfs/unconfined
2044  * @filp: file pointer, not actually used
2045  * @buf: where to put the result
2046  * @cn: maximum to send along
2047  * @ppos: where to start
2048  *
2049  * Returns number of bytes read or error code, as appropriate
2050  */
2051 static ssize_t smk_read_unconfined(struct file *filp, char __user *buf,
2052 					size_t cn, loff_t *ppos)
2053 {
2054 	char *smack = "";
2055 	ssize_t rc = -EINVAL;
2056 	int asize;
2057 
2058 	if (*ppos != 0)
2059 		return 0;
2060 
2061 	if (smack_unconfined != NULL)
2062 		smack = smack_unconfined->smk_known;
2063 
2064 	asize = strlen(smack) + 1;
2065 
2066 	if (cn >= asize)
2067 		rc = simple_read_from_buffer(buf, cn, ppos, smack, asize);
2068 
2069 	return rc;
2070 }
2071 
2072 /**
2073  * smk_write_unconfined - write() for smackfs/unconfined
2074  * @file: file pointer, not actually used
2075  * @buf: where to get the data from
2076  * @count: bytes sent
2077  * @ppos: where to start
2078  *
2079  * Returns number of bytes written or error code, as appropriate
2080  */
2081 static ssize_t smk_write_unconfined(struct file *file, const char __user *buf,
2082 					size_t count, loff_t *ppos)
2083 {
2084 	char *data;
2085 	struct smack_known *skp;
2086 	int rc = count;
2087 
2088 	if (!smack_privileged(CAP_MAC_ADMIN))
2089 		return -EPERM;
2090 
2091 	data = memdup_user_nul(buf, count);
2092 	if (IS_ERR(data))
2093 		return PTR_ERR(data);
2094 
2095 	/*
2096 	 * Clear the smack_unconfined on invalid label errors. This means
2097 	 * that we can pass a null string to unset the unconfined value.
2098 	 *
2099 	 * Importing will also reject a label beginning with '-',
2100 	 * so "-confine" will also work.
2101 	 *
2102 	 * But do so only on invalid label, not on system errors.
2103 	 */
2104 	skp = smk_import_entry(data, count);
2105 	if (PTR_ERR(skp) == -EINVAL)
2106 		skp = NULL;
2107 	else if (IS_ERR(skp)) {
2108 		rc = PTR_ERR(skp);
2109 		goto freeout;
2110 	}
2111 
2112 	smack_unconfined = skp;
2113 
2114 freeout:
2115 	kfree(data);
2116 	return rc;
2117 }
2118 
2119 static const struct file_operations smk_unconfined_ops = {
2120 	.read		= smk_read_unconfined,
2121 	.write		= smk_write_unconfined,
2122 	.llseek		= default_llseek,
2123 };
2124 #endif /* CONFIG_SECURITY_SMACK_BRINGUP */
2125 
2126 /**
2127  * smk_read_logging - read() for /smack/logging
2128  * @filp: file pointer, not actually used
2129  * @buf: where to put the result
2130  * @cn: maximum to send along
2131  * @ppos: where to start
2132  *
2133  * Returns number of bytes read or error code, as appropriate
2134  */
2135 static ssize_t smk_read_logging(struct file *filp, char __user *buf,
2136 				size_t count, loff_t *ppos)
2137 {
2138 	char temp[32];
2139 	ssize_t rc;
2140 
2141 	if (*ppos != 0)
2142 		return 0;
2143 
2144 	sprintf(temp, "%d\n", log_policy);
2145 	rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2146 	return rc;
2147 }
2148 
2149 /**
2150  * smk_write_logging - write() for /smack/logging
2151  * @file: file pointer, not actually used
2152  * @buf: where to get the data from
2153  * @count: bytes sent
2154  * @ppos: where to start
2155  *
2156  * Returns number of bytes written or error code, as appropriate
2157  */
2158 static ssize_t smk_write_logging(struct file *file, const char __user *buf,
2159 				size_t count, loff_t *ppos)
2160 {
2161 	char temp[32];
2162 	int i;
2163 
2164 	if (!smack_privileged(CAP_MAC_ADMIN))
2165 		return -EPERM;
2166 
2167 	if (count >= sizeof(temp) || count == 0)
2168 		return -EINVAL;
2169 
2170 	if (copy_from_user(temp, buf, count) != 0)
2171 		return -EFAULT;
2172 
2173 	temp[count] = '\0';
2174 
2175 	if (sscanf(temp, "%d", &i) != 1)
2176 		return -EINVAL;
2177 	if (i < 0 || i > 3)
2178 		return -EINVAL;
2179 	log_policy = i;
2180 	return count;
2181 }
2182 
2183 
2184 
2185 static const struct file_operations smk_logging_ops = {
2186 	.read		= smk_read_logging,
2187 	.write		= smk_write_logging,
2188 	.llseek		= default_llseek,
2189 };
2190 
2191 /*
2192  * Seq_file read operations for /smack/load-self
2193  */
2194 
2195 static void *load_self_seq_start(struct seq_file *s, loff_t *pos)
2196 {
2197 	struct task_smack *tsp = smack_cred(current_cred());
2198 
2199 	return smk_seq_start(s, pos, &tsp->smk_rules);
2200 }
2201 
2202 static void *load_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
2203 {
2204 	struct task_smack *tsp = smack_cred(current_cred());
2205 
2206 	return smk_seq_next(s, v, pos, &tsp->smk_rules);
2207 }
2208 
2209 static int load_self_seq_show(struct seq_file *s, void *v)
2210 {
2211 	struct list_head *list = v;
2212 	struct smack_rule *srp =
2213 		list_entry_rcu(list, struct smack_rule, list);
2214 
2215 	smk_rule_show(s, srp, SMK_LABELLEN);
2216 
2217 	return 0;
2218 }
2219 
2220 static const struct seq_operations load_self_seq_ops = {
2221 	.start = load_self_seq_start,
2222 	.next  = load_self_seq_next,
2223 	.show  = load_self_seq_show,
2224 	.stop  = smk_seq_stop,
2225 };
2226 
2227 
2228 /**
2229  * smk_open_load_self - open() for /smack/load-self2
2230  * @inode: inode structure representing file
2231  * @file: "load" file pointer
2232  *
2233  * For reading, use load_seq_* seq_file reading operations.
2234  */
2235 static int smk_open_load_self(struct inode *inode, struct file *file)
2236 {
2237 	return seq_open(file, &load_self_seq_ops);
2238 }
2239 
2240 /**
2241  * smk_write_load_self - write() for /smack/load-self
2242  * @file: file pointer, not actually used
2243  * @buf: where to get the data from
2244  * @count: bytes sent
2245  * @ppos: where to start - must be 0
2246  *
2247  */
2248 static ssize_t smk_write_load_self(struct file *file, const char __user *buf,
2249 			      size_t count, loff_t *ppos)
2250 {
2251 	struct task_smack *tsp = smack_cred(current_cred());
2252 
2253 	return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2254 				    &tsp->smk_rules_lock, SMK_FIXED24_FMT);
2255 }
2256 
2257 static const struct file_operations smk_load_self_ops = {
2258 	.open           = smk_open_load_self,
2259 	.read		= seq_read,
2260 	.llseek         = seq_lseek,
2261 	.write		= smk_write_load_self,
2262 	.release        = seq_release,
2263 };
2264 
2265 /**
2266  * smk_user_access - handle access check transaction
2267  * @file: file pointer
2268  * @buf: data from user space
2269  * @count: bytes sent
2270  * @ppos: where to start - must be 0
2271  */
2272 static ssize_t smk_user_access(struct file *file, const char __user *buf,
2273 				size_t count, loff_t *ppos, int format)
2274 {
2275 	struct smack_parsed_rule rule;
2276 	char *data;
2277 	int res;
2278 
2279 	data = simple_transaction_get(file, buf, count);
2280 	if (IS_ERR(data))
2281 		return PTR_ERR(data);
2282 
2283 	if (format == SMK_FIXED24_FMT) {
2284 		if (count < SMK_LOADLEN)
2285 			return -EINVAL;
2286 		res = smk_parse_rule(data, &rule, 0);
2287 	} else {
2288 		/*
2289 		 * simple_transaction_get() returns null-terminated data
2290 		 */
2291 		res = smk_parse_long_rule(data, &rule, 0, 3);
2292 	}
2293 
2294 	if (res >= 0)
2295 		res = smk_access(rule.smk_subject, rule.smk_object,
2296 				 rule.smk_access1, NULL);
2297 	else if (res != -ENOENT)
2298 		return res;
2299 
2300 	/*
2301 	 * smk_access() can return a value > 0 in the "bringup" case.
2302 	 */
2303 	data[0] = res >= 0 ? '1' : '0';
2304 	data[1] = '\0';
2305 
2306 	simple_transaction_set(file, 2);
2307 
2308 	if (format == SMK_FIXED24_FMT)
2309 		return SMK_LOADLEN;
2310 	return count;
2311 }
2312 
2313 /**
2314  * smk_write_access - handle access check transaction
2315  * @file: file pointer
2316  * @buf: data from user space
2317  * @count: bytes sent
2318  * @ppos: where to start - must be 0
2319  */
2320 static ssize_t smk_write_access(struct file *file, const char __user *buf,
2321 				size_t count, loff_t *ppos)
2322 {
2323 	return smk_user_access(file, buf, count, ppos, SMK_FIXED24_FMT);
2324 }
2325 
2326 static const struct file_operations smk_access_ops = {
2327 	.write		= smk_write_access,
2328 	.read		= simple_transaction_read,
2329 	.release	= simple_transaction_release,
2330 	.llseek		= generic_file_llseek,
2331 };
2332 
2333 
2334 /*
2335  * Seq_file read operations for /smack/load2
2336  */
2337 
2338 static int load2_seq_show(struct seq_file *s, void *v)
2339 {
2340 	struct list_head *list = v;
2341 	struct smack_rule *srp;
2342 	struct smack_known *skp =
2343 		list_entry_rcu(list, struct smack_known, list);
2344 
2345 	list_for_each_entry_rcu(srp, &skp->smk_rules, list)
2346 		smk_rule_show(s, srp, SMK_LONGLABEL);
2347 
2348 	return 0;
2349 }
2350 
2351 static const struct seq_operations load2_seq_ops = {
2352 	.start = load2_seq_start,
2353 	.next  = load2_seq_next,
2354 	.show  = load2_seq_show,
2355 	.stop  = smk_seq_stop,
2356 };
2357 
2358 /**
2359  * smk_open_load2 - open() for /smack/load2
2360  * @inode: inode structure representing file
2361  * @file: "load2" file pointer
2362  *
2363  * For reading, use load2_seq_* seq_file reading operations.
2364  */
2365 static int smk_open_load2(struct inode *inode, struct file *file)
2366 {
2367 	return seq_open(file, &load2_seq_ops);
2368 }
2369 
2370 /**
2371  * smk_write_load2 - write() for /smack/load2
2372  * @file: file pointer, not actually used
2373  * @buf: where to get the data from
2374  * @count: bytes sent
2375  * @ppos: where to start - must be 0
2376  *
2377  */
2378 static ssize_t smk_write_load2(struct file *file, const char __user *buf,
2379 				size_t count, loff_t *ppos)
2380 {
2381 	/*
2382 	 * Must have privilege.
2383 	 */
2384 	if (!smack_privileged(CAP_MAC_ADMIN))
2385 		return -EPERM;
2386 
2387 	return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2388 				    SMK_LONG_FMT);
2389 }
2390 
2391 static const struct file_operations smk_load2_ops = {
2392 	.open           = smk_open_load2,
2393 	.read		= seq_read,
2394 	.llseek         = seq_lseek,
2395 	.write		= smk_write_load2,
2396 	.release        = seq_release,
2397 };
2398 
2399 /*
2400  * Seq_file read operations for /smack/load-self2
2401  */
2402 
2403 static void *load_self2_seq_start(struct seq_file *s, loff_t *pos)
2404 {
2405 	struct task_smack *tsp = smack_cred(current_cred());
2406 
2407 	return smk_seq_start(s, pos, &tsp->smk_rules);
2408 }
2409 
2410 static void *load_self2_seq_next(struct seq_file *s, void *v, loff_t *pos)
2411 {
2412 	struct task_smack *tsp = smack_cred(current_cred());
2413 
2414 	return smk_seq_next(s, v, pos, &tsp->smk_rules);
2415 }
2416 
2417 static int load_self2_seq_show(struct seq_file *s, void *v)
2418 {
2419 	struct list_head *list = v;
2420 	struct smack_rule *srp =
2421 		list_entry_rcu(list, struct smack_rule, list);
2422 
2423 	smk_rule_show(s, srp, SMK_LONGLABEL);
2424 
2425 	return 0;
2426 }
2427 
2428 static const struct seq_operations load_self2_seq_ops = {
2429 	.start = load_self2_seq_start,
2430 	.next  = load_self2_seq_next,
2431 	.show  = load_self2_seq_show,
2432 	.stop  = smk_seq_stop,
2433 };
2434 
2435 /**
2436  * smk_open_load_self2 - open() for /smack/load-self2
2437  * @inode: inode structure representing file
2438  * @file: "load" file pointer
2439  *
2440  * For reading, use load_seq_* seq_file reading operations.
2441  */
2442 static int smk_open_load_self2(struct inode *inode, struct file *file)
2443 {
2444 	return seq_open(file, &load_self2_seq_ops);
2445 }
2446 
2447 /**
2448  * smk_write_load_self2 - write() for /smack/load-self2
2449  * @file: file pointer, not actually used
2450  * @buf: where to get the data from
2451  * @count: bytes sent
2452  * @ppos: where to start - must be 0
2453  *
2454  */
2455 static ssize_t smk_write_load_self2(struct file *file, const char __user *buf,
2456 			      size_t count, loff_t *ppos)
2457 {
2458 	struct task_smack *tsp = smack_cred(current_cred());
2459 
2460 	return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2461 				    &tsp->smk_rules_lock, SMK_LONG_FMT);
2462 }
2463 
2464 static const struct file_operations smk_load_self2_ops = {
2465 	.open           = smk_open_load_self2,
2466 	.read		= seq_read,
2467 	.llseek         = seq_lseek,
2468 	.write		= smk_write_load_self2,
2469 	.release        = seq_release,
2470 };
2471 
2472 /**
2473  * smk_write_access2 - handle access check transaction
2474  * @file: file pointer
2475  * @buf: data from user space
2476  * @count: bytes sent
2477  * @ppos: where to start - must be 0
2478  */
2479 static ssize_t smk_write_access2(struct file *file, const char __user *buf,
2480 					size_t count, loff_t *ppos)
2481 {
2482 	return smk_user_access(file, buf, count, ppos, SMK_LONG_FMT);
2483 }
2484 
2485 static const struct file_operations smk_access2_ops = {
2486 	.write		= smk_write_access2,
2487 	.read		= simple_transaction_read,
2488 	.release	= simple_transaction_release,
2489 	.llseek		= generic_file_llseek,
2490 };
2491 
2492 /**
2493  * smk_write_revoke_subj - write() for /smack/revoke-subject
2494  * @file: file pointer
2495  * @buf: data from user space
2496  * @count: bytes sent
2497  * @ppos: where to start - must be 0
2498  */
2499 static ssize_t smk_write_revoke_subj(struct file *file, const char __user *buf,
2500 				size_t count, loff_t *ppos)
2501 {
2502 	char *data;
2503 	const char *cp;
2504 	struct smack_known *skp;
2505 	struct smack_rule *sp;
2506 	struct list_head *rule_list;
2507 	struct mutex *rule_lock;
2508 	int rc = count;
2509 
2510 	if (*ppos != 0)
2511 		return -EINVAL;
2512 
2513 	if (!smack_privileged(CAP_MAC_ADMIN))
2514 		return -EPERM;
2515 
2516 	if (count == 0 || count > SMK_LONGLABEL)
2517 		return -EINVAL;
2518 
2519 	data = memdup_user(buf, count);
2520 	if (IS_ERR(data))
2521 		return PTR_ERR(data);
2522 
2523 	cp = smk_parse_smack(data, count);
2524 	if (IS_ERR(cp)) {
2525 		rc = PTR_ERR(cp);
2526 		goto out_data;
2527 	}
2528 
2529 	skp = smk_find_entry(cp);
2530 	if (skp == NULL)
2531 		goto out_cp;
2532 
2533 	rule_list = &skp->smk_rules;
2534 	rule_lock = &skp->smk_rules_lock;
2535 
2536 	mutex_lock(rule_lock);
2537 
2538 	list_for_each_entry_rcu(sp, rule_list, list)
2539 		sp->smk_access = 0;
2540 
2541 	mutex_unlock(rule_lock);
2542 
2543 out_cp:
2544 	kfree(cp);
2545 out_data:
2546 	kfree(data);
2547 
2548 	return rc;
2549 }
2550 
2551 static const struct file_operations smk_revoke_subj_ops = {
2552 	.write		= smk_write_revoke_subj,
2553 	.read		= simple_transaction_read,
2554 	.release	= simple_transaction_release,
2555 	.llseek		= generic_file_llseek,
2556 };
2557 
2558 /**
2559  * smk_init_sysfs - initialize /sys/fs/smackfs
2560  *
2561  */
2562 static int smk_init_sysfs(void)
2563 {
2564 	return sysfs_create_mount_point(fs_kobj, "smackfs");
2565 }
2566 
2567 /**
2568  * smk_write_change_rule - write() for /smack/change-rule
2569  * @file: file pointer
2570  * @buf: data from user space
2571  * @count: bytes sent
2572  * @ppos: where to start - must be 0
2573  */
2574 static ssize_t smk_write_change_rule(struct file *file, const char __user *buf,
2575 				size_t count, loff_t *ppos)
2576 {
2577 	/*
2578 	 * Must have privilege.
2579 	 */
2580 	if (!smack_privileged(CAP_MAC_ADMIN))
2581 		return -EPERM;
2582 
2583 	return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2584 				    SMK_CHANGE_FMT);
2585 }
2586 
2587 static const struct file_operations smk_change_rule_ops = {
2588 	.write		= smk_write_change_rule,
2589 	.read		= simple_transaction_read,
2590 	.release	= simple_transaction_release,
2591 	.llseek		= generic_file_llseek,
2592 };
2593 
2594 /**
2595  * smk_read_syslog - read() for smackfs/syslog
2596  * @filp: file pointer, not actually used
2597  * @buf: where to put the result
2598  * @cn: maximum to send along
2599  * @ppos: where to start
2600  *
2601  * Returns number of bytes read or error code, as appropriate
2602  */
2603 static ssize_t smk_read_syslog(struct file *filp, char __user *buf,
2604 				size_t cn, loff_t *ppos)
2605 {
2606 	struct smack_known *skp;
2607 	ssize_t rc = -EINVAL;
2608 	int asize;
2609 
2610 	if (*ppos != 0)
2611 		return 0;
2612 
2613 	if (smack_syslog_label == NULL)
2614 		skp = &smack_known_star;
2615 	else
2616 		skp = smack_syslog_label;
2617 
2618 	asize = strlen(skp->smk_known) + 1;
2619 
2620 	if (cn >= asize)
2621 		rc = simple_read_from_buffer(buf, cn, ppos, skp->smk_known,
2622 						asize);
2623 
2624 	return rc;
2625 }
2626 
2627 /**
2628  * smk_write_syslog - write() for smackfs/syslog
2629  * @file: file pointer, not actually used
2630  * @buf: where to get the data from
2631  * @count: bytes sent
2632  * @ppos: where to start
2633  *
2634  * Returns number of bytes written or error code, as appropriate
2635  */
2636 static ssize_t smk_write_syslog(struct file *file, const char __user *buf,
2637 				size_t count, loff_t *ppos)
2638 {
2639 	char *data;
2640 	struct smack_known *skp;
2641 	int rc = count;
2642 
2643 	if (!smack_privileged(CAP_MAC_ADMIN))
2644 		return -EPERM;
2645 
2646 	data = memdup_user_nul(buf, count);
2647 	if (IS_ERR(data))
2648 		return PTR_ERR(data);
2649 
2650 	skp = smk_import_entry(data, count);
2651 	if (IS_ERR(skp))
2652 		rc = PTR_ERR(skp);
2653 	else
2654 		smack_syslog_label = skp;
2655 
2656 	kfree(data);
2657 	return rc;
2658 }
2659 
2660 static const struct file_operations smk_syslog_ops = {
2661 	.read		= smk_read_syslog,
2662 	.write		= smk_write_syslog,
2663 	.llseek		= default_llseek,
2664 };
2665 
2666 /*
2667  * Seq_file read operations for /smack/relabel-self
2668  */
2669 
2670 static void *relabel_self_seq_start(struct seq_file *s, loff_t *pos)
2671 {
2672 	struct task_smack *tsp = smack_cred(current_cred());
2673 
2674 	return smk_seq_start(s, pos, &tsp->smk_relabel);
2675 }
2676 
2677 static void *relabel_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
2678 {
2679 	struct task_smack *tsp = smack_cred(current_cred());
2680 
2681 	return smk_seq_next(s, v, pos, &tsp->smk_relabel);
2682 }
2683 
2684 static int relabel_self_seq_show(struct seq_file *s, void *v)
2685 {
2686 	struct list_head *list = v;
2687 	struct smack_known_list_elem *sklep =
2688 		list_entry(list, struct smack_known_list_elem, list);
2689 
2690 	seq_puts(s, sklep->smk_label->smk_known);
2691 	seq_putc(s, ' ');
2692 
2693 	return 0;
2694 }
2695 
2696 static const struct seq_operations relabel_self_seq_ops = {
2697 	.start = relabel_self_seq_start,
2698 	.next  = relabel_self_seq_next,
2699 	.show  = relabel_self_seq_show,
2700 	.stop  = smk_seq_stop,
2701 };
2702 
2703 /**
2704  * smk_open_relabel_self - open() for /smack/relabel-self
2705  * @inode: inode structure representing file
2706  * @file: "relabel-self" file pointer
2707  *
2708  * Connect our relabel_self_seq_* operations with /smack/relabel-self
2709  * file_operations
2710  */
2711 static int smk_open_relabel_self(struct inode *inode, struct file *file)
2712 {
2713 	return seq_open(file, &relabel_self_seq_ops);
2714 }
2715 
2716 /**
2717  * smk_write_relabel_self - write() for /smack/relabel-self
2718  * @file: file pointer, not actually used
2719  * @buf: where to get the data from
2720  * @count: bytes sent
2721  * @ppos: where to start - must be 0
2722  *
2723  */
2724 static ssize_t smk_write_relabel_self(struct file *file, const char __user *buf,
2725 				size_t count, loff_t *ppos)
2726 {
2727 	char *data;
2728 	int rc;
2729 	LIST_HEAD(list_tmp);
2730 
2731 	/*
2732 	 * Must have privilege.
2733 	 */
2734 	if (!smack_privileged(CAP_MAC_ADMIN))
2735 		return -EPERM;
2736 
2737 	/*
2738 	 * Enough data must be present.
2739 	 */
2740 	if (*ppos != 0)
2741 		return -EINVAL;
2742 
2743 	data = memdup_user_nul(buf, count);
2744 	if (IS_ERR(data))
2745 		return PTR_ERR(data);
2746 
2747 	rc = smk_parse_label_list(data, &list_tmp);
2748 	kfree(data);
2749 
2750 	if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
2751 		struct cred *new;
2752 		struct task_smack *tsp;
2753 
2754 		new = prepare_creds();
2755 		if (!new) {
2756 			rc = -ENOMEM;
2757 			goto out;
2758 		}
2759 		tsp = smack_cred(new);
2760 		smk_destroy_label_list(&tsp->smk_relabel);
2761 		list_splice(&list_tmp, &tsp->smk_relabel);
2762 		commit_creds(new);
2763 		return count;
2764 	}
2765 out:
2766 	smk_destroy_label_list(&list_tmp);
2767 	return rc;
2768 }
2769 
2770 static const struct file_operations smk_relabel_self_ops = {
2771 	.open		= smk_open_relabel_self,
2772 	.read		= seq_read,
2773 	.llseek		= seq_lseek,
2774 	.write		= smk_write_relabel_self,
2775 	.release	= seq_release,
2776 };
2777 
2778 /**
2779  * smk_read_ptrace - read() for /smack/ptrace
2780  * @filp: file pointer, not actually used
2781  * @buf: where to put the result
2782  * @count: maximum to send along
2783  * @ppos: where to start
2784  *
2785  * Returns number of bytes read or error code, as appropriate
2786  */
2787 static ssize_t smk_read_ptrace(struct file *filp, char __user *buf,
2788 			       size_t count, loff_t *ppos)
2789 {
2790 	char temp[32];
2791 	ssize_t rc;
2792 
2793 	if (*ppos != 0)
2794 		return 0;
2795 
2796 	sprintf(temp, "%d\n", smack_ptrace_rule);
2797 	rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2798 	return rc;
2799 }
2800 
2801 /**
2802  * smk_write_ptrace - write() for /smack/ptrace
2803  * @file: file pointer
2804  * @buf: data from user space
2805  * @count: bytes sent
2806  * @ppos: where to start - must be 0
2807  */
2808 static ssize_t smk_write_ptrace(struct file *file, const char __user *buf,
2809 				size_t count, loff_t *ppos)
2810 {
2811 	char temp[32];
2812 	int i;
2813 
2814 	if (!smack_privileged(CAP_MAC_ADMIN))
2815 		return -EPERM;
2816 
2817 	if (*ppos != 0 || count >= sizeof(temp) || count == 0)
2818 		return -EINVAL;
2819 
2820 	if (copy_from_user(temp, buf, count) != 0)
2821 		return -EFAULT;
2822 
2823 	temp[count] = '\0';
2824 
2825 	if (sscanf(temp, "%d", &i) != 1)
2826 		return -EINVAL;
2827 	if (i < SMACK_PTRACE_DEFAULT || i > SMACK_PTRACE_MAX)
2828 		return -EINVAL;
2829 	smack_ptrace_rule = i;
2830 
2831 	return count;
2832 }
2833 
2834 static const struct file_operations smk_ptrace_ops = {
2835 	.write		= smk_write_ptrace,
2836 	.read		= smk_read_ptrace,
2837 	.llseek		= default_llseek,
2838 };
2839 
2840 /**
2841  * smk_fill_super - fill the smackfs superblock
2842  * @sb: the empty superblock
2843  * @fc: unused
2844  *
2845  * Fill in the well known entries for the smack filesystem
2846  *
2847  * Returns 0 on success, an error code on failure
2848  */
2849 static int smk_fill_super(struct super_block *sb, struct fs_context *fc)
2850 {
2851 	int rc;
2852 
2853 	static const struct tree_descr smack_files[] = {
2854 		[SMK_LOAD] = {
2855 			"load", &smk_load_ops, S_IRUGO|S_IWUSR},
2856 		[SMK_CIPSO] = {
2857 			"cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
2858 		[SMK_DOI] = {
2859 			"doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
2860 		[SMK_DIRECT] = {
2861 			"direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
2862 		[SMK_AMBIENT] = {
2863 			"ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
2864 		[SMK_NET4ADDR] = {
2865 			"netlabel", &smk_net4addr_ops, S_IRUGO|S_IWUSR},
2866 		[SMK_ONLYCAP] = {
2867 			"onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
2868 		[SMK_LOGGING] = {
2869 			"logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
2870 		[SMK_LOAD_SELF] = {
2871 			"load-self", &smk_load_self_ops, S_IRUGO|S_IWUGO},
2872 		[SMK_ACCESSES] = {
2873 			"access", &smk_access_ops, S_IRUGO|S_IWUGO},
2874 		[SMK_MAPPED] = {
2875 			"mapped", &smk_mapped_ops, S_IRUGO|S_IWUSR},
2876 		[SMK_LOAD2] = {
2877 			"load2", &smk_load2_ops, S_IRUGO|S_IWUSR},
2878 		[SMK_LOAD_SELF2] = {
2879 			"load-self2", &smk_load_self2_ops, S_IRUGO|S_IWUGO},
2880 		[SMK_ACCESS2] = {
2881 			"access2", &smk_access2_ops, S_IRUGO|S_IWUGO},
2882 		[SMK_CIPSO2] = {
2883 			"cipso2", &smk_cipso2_ops, S_IRUGO|S_IWUSR},
2884 		[SMK_REVOKE_SUBJ] = {
2885 			"revoke-subject", &smk_revoke_subj_ops,
2886 			S_IRUGO|S_IWUSR},
2887 		[SMK_CHANGE_RULE] = {
2888 			"change-rule", &smk_change_rule_ops, S_IRUGO|S_IWUSR},
2889 		[SMK_SYSLOG] = {
2890 			"syslog", &smk_syslog_ops, S_IRUGO|S_IWUSR},
2891 		[SMK_PTRACE] = {
2892 			"ptrace", &smk_ptrace_ops, S_IRUGO|S_IWUSR},
2893 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
2894 		[SMK_UNCONFINED] = {
2895 			"unconfined", &smk_unconfined_ops, S_IRUGO|S_IWUSR},
2896 #endif
2897 #if IS_ENABLED(CONFIG_IPV6)
2898 		[SMK_NET6ADDR] = {
2899 			"ipv6host", &smk_net6addr_ops, S_IRUGO|S_IWUSR},
2900 #endif /* CONFIG_IPV6 */
2901 		[SMK_RELABEL_SELF] = {
2902 			"relabel-self", &smk_relabel_self_ops,
2903 				S_IRUGO|S_IWUGO},
2904 		/* last one */
2905 			{""}
2906 	};
2907 
2908 	rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
2909 	if (rc != 0) {
2910 		printk(KERN_ERR "%s failed %d while creating inodes\n",
2911 			__func__, rc);
2912 		return rc;
2913 	}
2914 
2915 	return 0;
2916 }
2917 
2918 /**
2919  * smk_get_tree - get the smackfs superblock
2920  * @fc: The mount context, including any options
2921  *
2922  * Just passes everything along.
2923  *
2924  * Returns what the lower level code does.
2925  */
2926 static int smk_get_tree(struct fs_context *fc)
2927 {
2928 	return get_tree_single(fc, smk_fill_super);
2929 }
2930 
2931 static const struct fs_context_operations smk_context_ops = {
2932 	.get_tree	= smk_get_tree,
2933 };
2934 
2935 /**
2936  * smk_init_fs_context - Initialise a filesystem context for smackfs
2937  * @fc: The blank mount context
2938  */
2939 static int smk_init_fs_context(struct fs_context *fc)
2940 {
2941 	fc->ops = &smk_context_ops;
2942 	return 0;
2943 }
2944 
2945 static struct file_system_type smk_fs_type = {
2946 	.name		= "smackfs",
2947 	.init_fs_context = smk_init_fs_context,
2948 	.kill_sb	= kill_litter_super,
2949 };
2950 
2951 static struct vfsmount *smackfs_mount;
2952 
2953 static int __init smk_preset_netlabel(struct smack_known *skp)
2954 {
2955 	skp->smk_netlabel.domain = skp->smk_known;
2956 	skp->smk_netlabel.flags =
2957 		NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
2958 	return smk_netlbl_mls(smack_cipso_direct, skp->smk_known,
2959 				&skp->smk_netlabel, strlen(skp->smk_known));
2960 }
2961 
2962 /**
2963  * init_smk_fs - get the smackfs superblock
2964  *
2965  * register the smackfs
2966  *
2967  * Do not register smackfs if Smack wasn't enabled
2968  * on boot. We can not put this method normally under the
2969  * smack_init() code path since the security subsystem get
2970  * initialized before the vfs caches.
2971  *
2972  * Returns true if we were not chosen on boot or if
2973  * we were chosen and filesystem registration succeeded.
2974  */
2975 static int __init init_smk_fs(void)
2976 {
2977 	int err;
2978 	int rc;
2979 
2980 	if (smack_enabled == 0)
2981 		return 0;
2982 
2983 	err = smk_init_sysfs();
2984 	if (err)
2985 		printk(KERN_ERR "smackfs: sysfs mountpoint problem.\n");
2986 
2987 	err = register_filesystem(&smk_fs_type);
2988 	if (!err) {
2989 		smackfs_mount = kern_mount(&smk_fs_type);
2990 		if (IS_ERR(smackfs_mount)) {
2991 			printk(KERN_ERR "smackfs:  could not mount!\n");
2992 			err = PTR_ERR(smackfs_mount);
2993 			smackfs_mount = NULL;
2994 		}
2995 	}
2996 
2997 	smk_cipso_doi();
2998 	smk_unlbl_ambient(NULL);
2999 
3000 	rc = smk_preset_netlabel(&smack_known_floor);
3001 	if (err == 0 && rc < 0)
3002 		err = rc;
3003 	rc = smk_preset_netlabel(&smack_known_hat);
3004 	if (err == 0 && rc < 0)
3005 		err = rc;
3006 	rc = smk_preset_netlabel(&smack_known_huh);
3007 	if (err == 0 && rc < 0)
3008 		err = rc;
3009 	rc = smk_preset_netlabel(&smack_known_star);
3010 	if (err == 0 && rc < 0)
3011 		err = rc;
3012 	rc = smk_preset_netlabel(&smack_known_web);
3013 	if (err == 0 && rc < 0)
3014 		err = rc;
3015 
3016 	return err;
3017 }
3018 
3019 __initcall(init_smk_fs);
3020