Lines Matching +full:entry +full:- +full:name
1 // SPDX-License-Identifier: GPL-2.0
17 #include <linux/bpf-cgroup.h>
39 return head->ctl_table[0].child == sysctl_mount_point; in is_empty_dir()
44 dir->header.ctl_table[0].child = sysctl_mount_point; in set_empty_dir()
50 dir->header.ctl_table[0].child = NULL; in clear_empty_dir()
58 atomic_inc(&poll->event); in proc_sys_poll_notify()
59 wake_up_interruptible(&poll->wait); in proc_sys_poll_notify()
90 if (dir->header.parent) in sysctl_print_dir()
91 sysctl_print_dir(dir->header.parent); in sysctl_print_dir()
92 pr_cont("%s/", dir->header.ctl_table[0].procname); in sysctl_print_dir()
106 cmp = len1 - len2; in namecmp()
112 struct ctl_dir *dir, const char *name, int namelen) in find_entry() argument
115 struct ctl_table *entry; in find_entry() local
116 struct rb_node *node = dir->root.rb_node; in find_entry()
125 head = ctl_node->header; in find_entry()
126 entry = &head->ctl_table[ctl_node - head->node]; in find_entry()
127 procname = entry->procname; in find_entry()
129 cmp = namecmp(name, namelen, procname, strlen(procname)); in find_entry()
131 node = node->rb_left; in find_entry()
133 node = node->rb_right; in find_entry()
136 return entry; in find_entry()
142 static int insert_entry(struct ctl_table_header *head, struct ctl_table *entry) in insert_entry() argument
144 struct rb_node *node = &head->node[entry - head->ctl_table].node; in insert_entry()
145 struct rb_node **p = &head->parent->root.rb_node; in insert_entry()
147 const char *name = entry->procname; in insert_entry() local
148 int namelen = strlen(name); in insert_entry()
159 parent_head = parent_node->header; in insert_entry()
160 parent_entry = &parent_head->ctl_table[parent_node - parent_head->node]; in insert_entry()
161 parent_name = parent_entry->procname; in insert_entry()
163 cmp = namecmp(name, namelen, parent_name, strlen(parent_name)); in insert_entry()
165 p = &(*p)->rb_left; in insert_entry()
167 p = &(*p)->rb_right; in insert_entry()
169 pr_err("sysctl duplicate entry: "); in insert_entry()
170 sysctl_print_dir(head->parent); in insert_entry()
171 pr_cont("/%s\n", entry->procname); in insert_entry()
172 return -EEXIST; in insert_entry()
177 rb_insert_color(node, &head->parent->root); in insert_entry()
181 static void erase_entry(struct ctl_table_header *head, struct ctl_table *entry) in erase_entry() argument
183 struct rb_node *node = &head->node[entry - head->ctl_table].node; in erase_entry()
185 rb_erase(node, &head->parent->root); in erase_entry()
192 head->ctl_table = table; in init_header()
193 head->ctl_table_arg = table; in init_header()
194 head->used = 0; in init_header()
195 head->count = 1; in init_header()
196 head->nreg = 1; in init_header()
197 head->unregistering = NULL; in init_header()
198 head->root = root; in init_header()
199 head->set = set; in init_header()
200 head->parent = NULL; in init_header()
201 head->node = node; in init_header()
202 INIT_HLIST_HEAD(&head->inodes); in init_header()
204 struct ctl_table *entry; in init_header() local
205 for (entry = table; entry->procname; entry++, node++) in init_header()
206 node->header = head; in init_header()
212 struct ctl_table *entry; in erase_header() local
213 for (entry = head->ctl_table; entry->procname; entry++) in erase_header()
214 erase_entry(head, entry); in erase_header()
219 struct ctl_table *entry; in insert_header() local
223 if (is_empty_dir(&dir->header)) in insert_header()
224 return -EROFS; in insert_header()
227 if (header->ctl_table == sysctl_mount_point) { in insert_header()
228 if (!RB_EMPTY_ROOT(&dir->root)) in insert_header()
229 return -EINVAL; in insert_header()
233 dir->header.nreg++; in insert_header()
234 header->parent = dir; in insert_header()
238 for (entry = header->ctl_table; entry->procname; entry++) { in insert_header()
239 err = insert_entry(header, entry); in insert_header()
248 if (header->ctl_table == sysctl_mount_point) in insert_header()
250 header->parent = NULL; in insert_header()
251 drop_sysctl_table(&dir->header); in insert_header()
258 if (unlikely(p->unregistering)) in use_table()
260 p->used++; in use_table()
267 if (!--p->used) in unuse_table()
268 if (unlikely(p->unregistering)) in unuse_table()
269 complete(p->unregistering); in unuse_table()
274 proc_invalidate_siblings_dcache(&head->inodes, &sysctl_lock); in proc_sys_invalidate_dcache()
281 * if p->used is 0, nobody will ever touch that entry again; in start_unregistering()
284 if (unlikely(p->used)) { in start_unregistering()
287 p->unregistering = &wait; in start_unregistering()
291 /* anything non-NULL; we'll never dereference it */ in start_unregistering()
292 p->unregistering = ERR_PTR(-EINVAL); in start_unregistering()
313 head = ERR_PTR(-ENOENT); in sysctl_head_grab()
330 struct ctl_table_set *set = &root->default_set; in lookup_header_set()
331 if (root->lookup) in lookup_header_set()
332 set = root->lookup(root); in lookup_header_set()
338 const char *name, int namelen) in lookup_entry() argument
341 struct ctl_table *entry; in lookup_entry() local
344 entry = find_entry(&head, dir, name, namelen); in lookup_entry()
345 if (entry && use_table(head)) in lookup_entry()
348 entry = NULL; in lookup_entry()
350 return entry; in lookup_entry()
359 if (use_table(ctl_node->header)) in first_usable_entry()
369 struct ctl_table *entry = NULL; in first_entry() local
373 ctl_node = first_usable_entry(rb_first(&dir->root)); in first_entry()
376 head = ctl_node->header; in first_entry()
377 entry = &head->ctl_table[ctl_node - head->node]; in first_entry()
380 *pentry = entry; in first_entry()
386 struct ctl_table *entry = *pentry; in next_entry() local
387 struct ctl_node *ctl_node = &head->node[entry - head->ctl_table]; in next_entry()
392 ctl_node = first_usable_entry(rb_next(&ctl_node->node)); in next_entry()
396 head = ctl_node->header; in next_entry()
397 entry = &head->ctl_table[ctl_node - head->node]; in next_entry()
400 *pentry = entry; in next_entry()
416 return -EACCES; in test_perm()
421 struct ctl_table_root *root = head->root; in sysctl_perm()
424 if (root->permissions) in sysctl_perm()
425 mode = root->permissions(head, table); in sysctl_perm()
427 mode = table->mode; in sysctl_perm()
435 struct ctl_table_root *root = head->root; in proc_sys_make_inode()
441 return ERR_PTR(-ENOMEM); in proc_sys_make_inode()
443 inode->i_ino = get_next_ino(); in proc_sys_make_inode()
448 if (unlikely(head->unregistering)) { in proc_sys_make_inode()
451 return ERR_PTR(-ENOENT); in proc_sys_make_inode()
453 ei->sysctl = head; in proc_sys_make_inode()
454 ei->sysctl_entry = table; in proc_sys_make_inode()
455 hlist_add_head_rcu(&ei->sibling_inodes, &head->inodes); in proc_sys_make_inode()
456 head->count++; in proc_sys_make_inode()
459 inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); in proc_sys_make_inode()
460 inode->i_mode = table->mode; in proc_sys_make_inode()
461 if (!S_ISDIR(table->mode)) { in proc_sys_make_inode()
462 inode->i_mode |= S_IFREG; in proc_sys_make_inode()
463 inode->i_op = &proc_sys_inode_operations; in proc_sys_make_inode()
464 inode->i_fop = &proc_sys_file_operations; in proc_sys_make_inode()
466 inode->i_mode |= S_IFDIR; in proc_sys_make_inode()
467 inode->i_op = &proc_sys_dir_operations; in proc_sys_make_inode()
468 inode->i_fop = &proc_sys_dir_file_operations; in proc_sys_make_inode()
473 if (root->set_ownership) in proc_sys_make_inode()
474 root->set_ownership(head, table, &inode->i_uid, &inode->i_gid); in proc_sys_make_inode()
476 inode->i_uid = GLOBAL_ROOT_UID; in proc_sys_make_inode()
477 inode->i_gid = GLOBAL_ROOT_GID; in proc_sys_make_inode()
486 hlist_del_init_rcu(&PROC_I(inode)->sibling_inodes); in proc_sys_evict_inode()
487 if (!--head->count) in proc_sys_evict_inode()
494 struct ctl_table_header *head = PROC_I(inode)->sysctl; in grab_header()
505 const struct qstr *name = &dentry->d_name; in proc_sys_lookup() local
508 struct dentry *err = ERR_PTR(-ENOENT); in proc_sys_lookup()
517 p = lookup_entry(&h, ctl_dir, name->name, name->len); in proc_sys_lookup()
521 if (S_ISLNK(p->mode)) { in proc_sys_lookup()
528 inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p); in proc_sys_lookup()
547 struct inode *inode = file_inode(iocb->ki_filp); in proc_sys_call_handler()
549 struct ctl_table *table = PROC_I(inode)->sysctl_entry; in proc_sys_call_handler()
561 error = -EPERM; in proc_sys_call_handler()
565 /* if that can happen at all, it should be -EINVAL, not -EISDIR */ in proc_sys_call_handler()
566 error = -EINVAL; in proc_sys_call_handler()
567 if (!table->proc_handler) in proc_sys_call_handler()
571 error = -ENOMEM; in proc_sys_call_handler()
579 error = -EFAULT; in proc_sys_call_handler()
586 &iocb->ki_pos); in proc_sys_call_handler()
591 error = table->proc_handler(table, write, kbuf, &count, &iocb->ki_pos); in proc_sys_call_handler()
596 error = -EFAULT; in proc_sys_call_handler()
623 struct ctl_table *table = PROC_I(inode)->sysctl_entry; in proc_sys_open()
629 if (table->poll) in proc_sys_open()
630 filp->private_data = proc_sys_poll_event(table->poll); in proc_sys_open()
641 struct ctl_table *table = PROC_I(inode)->sysctl_entry; in proc_sys_poll()
649 if (!table->proc_handler) in proc_sys_poll()
652 if (!table->poll) in proc_sys_poll()
655 event = (unsigned long)filp->private_data; in proc_sys_poll()
656 poll_wait(filp, &table->poll->wait, wait); in proc_sys_poll()
658 if (event != atomic_read(&table->poll->event)) { in proc_sys_poll()
659 filp->private_data = proc_sys_poll_event(table->poll); in proc_sys_poll()
674 struct dentry *child, *dir = file->f_path.dentry; in proc_sys_fill_cache()
680 qname.name = table->procname; in proc_sys_fill_cache()
681 qname.len = strlen(table->procname); in proc_sys_fill_cache()
682 qname.hash = full_name_hash(dir, qname.name, qname.len); in proc_sys_fill_cache()
692 inode = proc_sys_make_inode(dir->d_sb, head, table); in proc_sys_fill_cache()
712 ino = inode->i_ino; in proc_sys_fill_cache()
713 type = inode->i_mode >> 12; in proc_sys_fill_cache()
715 return dir_emit(ctx, qname.name, qname.len, ino, type); in proc_sys_fill_cache()
745 if ((*pos)++ < ctx->pos) in scan()
748 if (unlikely(S_ISLNK(table->mode))) in scan()
754 ctx->pos = *pos; in scan()
763 struct ctl_table *entry; in proc_sys_readdir() local
777 for (first_entry(ctl_dir, &h, &entry); h; next_entry(&h, &entry)) { in proc_sys_readdir()
778 if (!scan(h, entry, &pos, file, ctx)) { in proc_sys_readdir()
799 if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) in proc_sys_permission()
800 return -EACCES; in proc_sys_permission()
806 table = PROC_I(inode)->sysctl_entry; in proc_sys_permission()
807 if (!table) /* global root - r-xr-xr-x */ in proc_sys_permission()
808 error = mask & MAY_WRITE ? -EACCES : 0; in proc_sys_permission()
809 else /* Use the permissions on the sysctl table entry */ in proc_sys_permission()
821 if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) in proc_sys_setattr()
822 return -EPERM; in proc_sys_setattr()
836 struct inode *inode = d_inode(path->dentry); in proc_sys_getattr()
838 struct ctl_table *table = PROC_I(inode)->sysctl_entry; in proc_sys_getattr()
845 stat->mode = (stat->mode & S_IFMT) | table->mode; in proc_sys_getattr()
883 return -ECHILD; in proc_sys_revalidate()
884 return !PROC_I(d_inode(dentry))->sysctl->unregistering; in proc_sys_revalidate()
889 return !!PROC_I(d_inode(dentry))->sysctl->unregistering; in proc_sys_delete()
894 struct ctl_table_set *set = p->set; in sysctl_is_seen()
897 if (p->unregistering) in sysctl_is_seen()
899 else if (!set->is_seen) in sysctl_is_seen()
902 res = set->is_seen(set); in sysctl_is_seen()
908 unsigned int len, const char *str, const struct qstr *name) in proc_sys_compare() argument
913 /* Although proc doesn't have negative dentries, rcu-walk means in proc_sys_compare()
919 if (name->len != len) in proc_sys_compare()
921 if (memcmp(name->name, str, len)) in proc_sys_compare()
923 head = rcu_dereference(PROC_I(inode)->sysctl); in proc_sys_compare()
934 const char *name, int namelen) in find_subdir() argument
937 struct ctl_table *entry; in find_subdir() local
939 entry = find_entry(&head, dir, name, namelen); in find_subdir()
940 if (!entry) in find_subdir()
941 return ERR_PTR(-ENOENT); in find_subdir()
942 if (!S_ISDIR(entry->mode)) in find_subdir()
943 return ERR_PTR(-ENOTDIR); in find_subdir()
948 const char *name, int namelen) in new_dir() argument
964 memcpy(new_name, name, namelen); in new_dir()
968 init_header(&new->header, set->dir.header.root, set, node, table); in new_dir()
974 * get_subdir - find or create a subdir with the specified name.
976 * @name: The name of the subdirectory to find or create
977 * @namelen: The length of name
986 const char *name, int namelen) in get_subdir() argument
988 struct ctl_table_set *set = dir->header.set; in get_subdir()
993 subdir = find_subdir(dir, name, namelen); in get_subdir()
996 if (PTR_ERR(subdir) != -ENOENT) in get_subdir()
1000 new = new_dir(set, name, namelen); in get_subdir()
1002 subdir = ERR_PTR(-ENOMEM); in get_subdir()
1007 subdir = find_subdir(dir, name, namelen); in get_subdir()
1010 if (PTR_ERR(subdir) != -ENOENT) in get_subdir()
1013 /* Nope. Use the our freshly made directory entry. */ in get_subdir()
1014 err = insert_header(dir, &new->header); in get_subdir()
1020 subdir->header.nreg++; in get_subdir()
1026 namelen, namelen, name, PTR_ERR(subdir)); in get_subdir()
1028 drop_sysctl_table(&dir->header); in get_subdir()
1030 drop_sysctl_table(&new->header); in get_subdir()
1039 if (!dir->header.parent) in xlate_dir()
1040 return &set->dir; in xlate_dir()
1041 parent = xlate_dir(set, dir->header.parent); in xlate_dir()
1044 procname = dir->header.ctl_table[0].procname; in xlate_dir()
1054 struct ctl_table *entry; in sysctl_follow_link() local
1060 root = (*pentry)->data; in sysctl_follow_link()
1062 dir = xlate_dir(set, (*phead)->parent); in sysctl_follow_link()
1066 const char *procname = (*pentry)->procname; in sysctl_follow_link()
1068 entry = find_entry(&head, dir, procname, strlen(procname)); in sysctl_follow_link()
1069 ret = -ENOENT; in sysctl_follow_link()
1070 if (entry && use_table(head)) { in sysctl_follow_link()
1073 *pentry = entry; in sysctl_follow_link()
1092 path, table->procname, &vaf); in sysctl_err()
1095 return -EINVAL; in sysctl_err()
1102 if ((table->proc_handler == proc_douintvec) || in sysctl_check_table_array()
1103 (table->proc_handler == proc_douintvec_minmax)) { in sysctl_check_table_array()
1104 if (table->maxlen != sizeof(unsigned int)) in sysctl_check_table_array()
1114 for (; table->procname; table++) { in sysctl_check_table()
1115 if (table->child) in sysctl_check_table()
1118 if ((table->proc_handler == proc_dostring) || in sysctl_check_table()
1119 (table->proc_handler == proc_dointvec) || in sysctl_check_table()
1120 (table->proc_handler == proc_douintvec) || in sysctl_check_table()
1121 (table->proc_handler == proc_douintvec_minmax) || in sysctl_check_table()
1122 (table->proc_handler == proc_dointvec_minmax) || in sysctl_check_table()
1123 (table->proc_handler == proc_dointvec_jiffies) || in sysctl_check_table()
1124 (table->proc_handler == proc_dointvec_userhz_jiffies) || in sysctl_check_table()
1125 (table->proc_handler == proc_dointvec_ms_jiffies) || in sysctl_check_table()
1126 (table->proc_handler == proc_doulongvec_minmax) || in sysctl_check_table()
1127 (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) { in sysctl_check_table()
1128 if (!table->data) in sysctl_check_table()
1130 if (!table->maxlen) in sysctl_check_table()
1135 if (!table->proc_handler) in sysctl_check_table()
1138 if ((table->mode & (S_IRUGO|S_IWUGO)) != table->mode) in sysctl_check_table()
1140 table->mode); in sysctl_check_table()
1148 struct ctl_table *link_table, *entry, *link; in new_links() local
1156 for (entry = table; entry->procname; entry++) { in new_links()
1158 name_bytes += strlen(entry->procname) + 1; in new_links()
1174 for (link = link_table, entry = table; entry->procname; link++, entry++) { in new_links()
1175 int len = strlen(entry->procname) + 1; in new_links()
1176 memcpy(link_name, entry->procname, len); in new_links()
1177 link->procname = link_name; in new_links()
1178 link->mode = S_IFLNK|S_IRWXUGO; in new_links()
1179 link->data = link_root; in new_links()
1182 init_header(links, dir->header.root, dir->header.set, node, link_table); in new_links()
1183 links->nreg = nr_entries; in new_links()
1192 struct ctl_table *entry, *link; in get_links() local
1194 /* Are there links available for every entry in table? */ in get_links()
1195 for (entry = table; entry->procname; entry++) { in get_links()
1196 const char *procname = entry->procname; in get_links()
1200 if (S_ISDIR(link->mode) && S_ISDIR(entry->mode)) in get_links()
1202 if (S_ISLNK(link->mode) && (link->data == link_root)) in get_links()
1208 for (entry = table; entry->procname; entry++) { in get_links()
1209 const char *procname = entry->procname; in get_links()
1211 head->nreg++; in get_links()
1223 if (head->set == root_set) in insert_links()
1226 core_parent = xlate_dir(root_set, head->parent); in insert_links()
1230 if (get_links(core_parent, head->ctl_table, head->root)) in insert_links()
1233 core_parent->header.nreg++; in insert_links()
1236 links = new_links(core_parent, head->ctl_table, head->root); in insert_links()
1239 err = -ENOMEM; in insert_links()
1244 if (get_links(core_parent, head->ctl_table, head->root)) { in insert_links()
1253 drop_sysctl_table(&core_parent->header); in insert_links()
1258 * __register_sysctl_table - register a leaf sysctl table
1261 * @table: the top-level table structure
1264 * array. A completely 0 filled entry terminates the table.
1268 * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
1271 * data - a pointer to data for use by proc_handler
1273 * maxlen - the maximum size in bytes of the data
1275 * mode - the file permissions for the /proc/sys file
1277 * child - must be %NULL.
1279 * proc_handler - the text handler routine (described below)
1281 * extra1, extra2 - extra pointers usable by the proc handler routines
1284 * under /proc; non-leaf nodes will be represented by directories.
1287 * Several default handlers are available to cover common cases -
1303 struct ctl_table_root *root = set->dir.header.root; in __register_sysctl_table()
1305 const char *name, *nextname; in __register_sysctl_table() local
1307 struct ctl_table *entry; in __register_sysctl_table() local
1311 for (entry = table; entry->procname; entry++) in __register_sysctl_table()
1325 dir = &set->dir; in __register_sysctl_table()
1327 dir->header.nreg++; in __register_sysctl_table()
1331 for (name = path; name; name = nextname) { in __register_sysctl_table()
1333 nextname = strchr(name, '/'); in __register_sysctl_table()
1335 namelen = nextname - name; in __register_sysctl_table()
1338 namelen = strlen(name); in __register_sysctl_table()
1343 dir = get_subdir(dir, name, namelen); in __register_sysctl_table()
1352 drop_sysctl_table(&dir->header); in __register_sysctl_table()
1358 drop_sysctl_table(&dir->header); in __register_sysctl_table()
1367 * register_sysctl - register a sysctl table
1372 * array. A completely 0 filled entry terminates the table.
1383 static char *append_path(const char *path, char *pos, const char *name) in append_path() argument
1386 namelen = strlen(name); in append_path()
1387 if (((pos - path) + namelen + 2) >= PATH_MAX) in append_path()
1389 memcpy(pos, name, namelen); in append_path()
1400 struct ctl_table *entry; in count_subheaders() local
1403 if (!table || !table->procname) in count_subheaders()
1406 for (entry = table; entry->procname; entry++) { in count_subheaders()
1407 if (entry->child) in count_subheaders()
1408 nr_subheaders += count_subheaders(entry->child); in count_subheaders()
1420 struct ctl_table *entry, *files; in register_leaf_sysctl_tables() local
1423 int err = -ENOMEM; in register_leaf_sysctl_tables()
1425 for (entry = table; entry->procname; entry++) { in register_leaf_sysctl_tables()
1426 if (entry->child) in register_leaf_sysctl_tables()
1442 for (new = files, entry = table; entry->procname; entry++) { in register_leaf_sysctl_tables()
1443 if (entry->child) in register_leaf_sysctl_tables()
1445 *new = *entry; in register_leaf_sysctl_tables()
1460 header->ctl_table_arg = ctl_table_arg; in register_leaf_sysctl_tables()
1466 for (entry = table; entry->procname; entry++) { in register_leaf_sysctl_tables()
1469 if (!entry->child) in register_leaf_sysctl_tables()
1472 err = -ENAMETOOLONG; in register_leaf_sysctl_tables()
1473 child_pos = append_path(path, pos, entry->procname); in register_leaf_sysctl_tables()
1478 set, entry->child); in register_leaf_sysctl_tables()
1490 * __register_sysctl_paths - register a sysctl table hierarchy
1493 * @table: the top-level table structure
1496 * array. A completely 0 filled entry terminates the table.
1515 for (component = path; component->procname; component++) { in __register_sysctl_paths()
1516 pos = append_path(new_path, pos, component->procname); in __register_sysctl_paths()
1520 while (table->procname && table->child && !table[1].procname) { in __register_sysctl_paths()
1521 pos = append_path(new_path, pos, table->procname); in __register_sysctl_paths()
1524 table = table->child; in __register_sysctl_paths()
1529 header->ctl_table_arg = ctl_table_arg; in __register_sysctl_paths()
1538 header->ctl_table_arg = ctl_table_arg; in __register_sysctl_paths()
1551 struct ctl_table_header *subh = *(--subheader); in __register_sysctl_paths()
1552 struct ctl_table *table = subh->ctl_table_arg; in __register_sysctl_paths()
1562 * register_sysctl_table_path - register a sysctl table hierarchy
1564 * @table: the top-level table structure
1567 * array. A completely 0 filled entry terminates the table.
1580 * register_sysctl_table - register a sysctl table hierarchy
1581 * @table: the top-level table structure
1584 * array. A completely 0 filled entry terminates the table.
1599 struct ctl_table_root *root = header->root; in put_links()
1600 struct ctl_dir *parent = header->parent; in put_links()
1602 struct ctl_table *entry; in put_links() local
1604 if (header->set == root_set) in put_links()
1611 for (entry = header->ctl_table; entry->procname; entry++) { in put_links()
1614 const char *name = entry->procname; in put_links() local
1616 link = find_entry(&link_head, core_parent, name, strlen(name)); in put_links()
1618 ((S_ISDIR(link->mode) && S_ISDIR(entry->mode)) || in put_links()
1619 (S_ISLNK(link->mode) && (link->data == root)))) { in put_links()
1625 pr_cont("/%s\n", name); in put_links()
1632 struct ctl_dir *parent = header->parent; in drop_sysctl_table()
1634 if (--header->nreg) in drop_sysctl_table()
1642 if (!--header->count) in drop_sysctl_table()
1646 drop_sysctl_table(&parent->header); in drop_sysctl_table()
1650 * unregister_sysctl_table - unregister a sysctl table hierarchy
1664 nr_subheaders = count_subheaders(header->ctl_table_arg); in unregister_sysctl_table()
1670 for (i = nr_subheaders -1; i >= 0; i--) { in unregister_sysctl_table()
1672 struct ctl_table *table = subh->ctl_table_arg; in unregister_sysctl_table()
1691 set->is_seen = is_seen; in setup_sysctl_set()
1692 init_header(&set->dir.header, root, set, NULL, root_table); in setup_sysctl_set()
1697 WARN_ON(!RB_EMPTY_ROOT(&set->dir.root)); in retire_sysctl_set()
1705 proc_sys_root->proc_iops = &proc_sys_dir_operations; in proc_sys_init()
1706 proc_sys_root->proc_dir_ops = &proc_sys_dir_file_operations; in proc_sys_init()
1707 proc_sys_root->nlink = 0; in proc_sys_init()
1720 * place and only keep the historical name for compatibility. This is not meant
1739 for (alias = &sysctl_aliases[0]; alias->kernel_param != NULL; alias++) { in sysctl_find_alias()
1740 if (strcmp(alias->kernel_param, param) == 0) in sysctl_find_alias()
1741 return alias->sysctl_param; in sysctl_find_alias()
1760 if (strncmp(param, "sysctl", sizeof("sysctl") - 1) == 0) { in process_sysctl_arg()
1761 param += sizeof("sysctl") - 1; in process_sysctl_arg()
1800 file = file_open_root((*proc_mnt)->mnt_root, *proc_mnt, path, O_WRONLY, 0); in process_sysctl_arg()
1803 if (err == -ENOENT) in process_sysctl_arg()
1806 else if (err == -EACCES) in process_sysctl_arg()
1807 pr_err("Failed to set sysctl parameter '%s=%s': permission denied (read-only?)\n", in process_sysctl_arg()
1818 if (err == -EINVAL) in process_sysctl_arg()
1848 NULL, 0, -1, -1, &proc_mnt, process_sysctl_arg); in do_sysctl_args()