Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-only */
2 : : /*
3 : : * kernfs.h - pseudo filesystem decoupled from vfs locking
4 : : */
5 : :
6 : : #ifndef __LINUX_KERNFS_H
7 : : #define __LINUX_KERNFS_H
8 : :
9 : : #include <linux/kernel.h>
10 : : #include <linux/err.h>
11 : : #include <linux/list.h>
12 : : #include <linux/mutex.h>
13 : : #include <linux/idr.h>
14 : : #include <linux/lockdep.h>
15 : : #include <linux/rbtree.h>
16 : : #include <linux/atomic.h>
17 : : #include <linux/uidgid.h>
18 : : #include <linux/wait.h>
19 : :
20 : : struct file;
21 : : struct dentry;
22 : : struct iattr;
23 : : struct seq_file;
24 : : struct vm_area_struct;
25 : : struct super_block;
26 : : struct file_system_type;
27 : : struct poll_table_struct;
28 : : struct fs_context;
29 : :
30 : : struct kernfs_fs_context;
31 : : struct kernfs_open_node;
32 : : struct kernfs_iattrs;
33 : :
34 : : enum kernfs_node_type {
35 : : KERNFS_DIR = 0x0001,
36 : : KERNFS_FILE = 0x0002,
37 : : KERNFS_LINK = 0x0004,
38 : : };
39 : :
40 : : #define KERNFS_TYPE_MASK 0x000f
41 : : #define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK
42 : :
43 : : enum kernfs_node_flag {
44 : : KERNFS_ACTIVATED = 0x0010,
45 : : KERNFS_NS = 0x0020,
46 : : KERNFS_HAS_SEQ_SHOW = 0x0040,
47 : : KERNFS_HAS_MMAP = 0x0080,
48 : : KERNFS_LOCKDEP = 0x0100,
49 : : KERNFS_SUICIDAL = 0x0400,
50 : : KERNFS_SUICIDED = 0x0800,
51 : : KERNFS_EMPTY_DIR = 0x1000,
52 : : KERNFS_HAS_RELEASE = 0x2000,
53 : : };
54 : :
55 : : /* @flags for kernfs_create_root() */
56 : : enum kernfs_root_flag {
57 : : /*
58 : : * kernfs_nodes are created in the deactivated state and invisible.
59 : : * They require explicit kernfs_activate() to become visible. This
60 : : * can be used to make related nodes become visible atomically
61 : : * after all nodes are created successfully.
62 : : */
63 : : KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
64 : :
65 : : /*
66 : : * For regular files, if the opener has CAP_DAC_OVERRIDE, open(2)
67 : : * succeeds regardless of the RW permissions. sysfs had an extra
68 : : * layer of enforcement where open(2) fails with -EACCES regardless
69 : : * of CAP_DAC_OVERRIDE if the permission doesn't have the
70 : : * respective read or write access at all (none of S_IRUGO or
71 : : * S_IWUGO) or the respective operation isn't implemented. The
72 : : * following flag enables that behavior.
73 : : */
74 : : KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
75 : :
76 : : /*
77 : : * The filesystem supports exportfs operation, so userspace can use
78 : : * fhandle to access nodes of the fs.
79 : : */
80 : : KERNFS_ROOT_SUPPORT_EXPORTOP = 0x0004,
81 : : };
82 : :
83 : : /* type-specific structures for kernfs_node union members */
84 : : struct kernfs_elem_dir {
85 : : unsigned long subdirs;
86 : : /* children rbtree starts here and goes through kn->rb */
87 : : struct rb_root children;
88 : :
89 : : /*
90 : : * The kernfs hierarchy this directory belongs to. This fits
91 : : * better directly in kernfs_node but is here to save space.
92 : : */
93 : : struct kernfs_root *root;
94 : : };
95 : :
96 : : struct kernfs_elem_symlink {
97 : : struct kernfs_node *target_kn;
98 : : };
99 : :
100 : : struct kernfs_elem_attr {
101 : : const struct kernfs_ops *ops;
102 : : struct kernfs_open_node *open;
103 : : loff_t size;
104 : : struct kernfs_node *notify_next; /* for kernfs_notify() */
105 : : };
106 : :
107 : : /* represent a kernfs node */
108 : : union kernfs_node_id {
109 : : struct {
110 : : /*
111 : : * blktrace will export this struct as a simplified 'struct
112 : : * fid' (which is a big data struction), so userspace can use
113 : : * it to find kernfs node. The layout must match the first two
114 : : * fields of 'struct fid' exactly.
115 : : */
116 : : u32 ino;
117 : : u32 generation;
118 : : };
119 : : u64 id;
120 : : };
121 : :
122 : : /*
123 : : * kernfs_node - the building block of kernfs hierarchy. Each and every
124 : : * kernfs node is represented by single kernfs_node. Most fields are
125 : : * private to kernfs and shouldn't be accessed directly by kernfs users.
126 : : *
127 : : * As long as s_count reference is held, the kernfs_node itself is
128 : : * accessible. Dereferencing elem or any other outer entity requires
129 : : * active reference.
130 : : */
131 : : struct kernfs_node {
132 : : atomic_t count;
133 : : atomic_t active;
134 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
135 : : struct lockdep_map dep_map;
136 : : #endif
137 : : /*
138 : : * Use kernfs_get_parent() and kernfs_name/path() instead of
139 : : * accessing the following two fields directly. If the node is
140 : : * never moved to a different parent, it is safe to access the
141 : : * parent directly.
142 : : */
143 : : struct kernfs_node *parent;
144 : : const char *name;
145 : :
146 : : struct rb_node rb;
147 : :
148 : : const void *ns; /* namespace tag */
149 : : unsigned int hash; /* ns + name hash */
150 : : union {
151 : : struct kernfs_elem_dir dir;
152 : : struct kernfs_elem_symlink symlink;
153 : : struct kernfs_elem_attr attr;
154 : : };
155 : :
156 : : void *priv;
157 : :
158 : : union kernfs_node_id id;
159 : : unsigned short flags;
160 : : umode_t mode;
161 : : struct kernfs_iattrs *iattr;
162 : : };
163 : :
164 : : /*
165 : : * kernfs_syscall_ops may be specified on kernfs_create_root() to support
166 : : * syscalls. These optional callbacks are invoked on the matching syscalls
167 : : * and can perform any kernfs operations which don't necessarily have to be
168 : : * the exact operation requested. An active reference is held for each
169 : : * kernfs_node parameter.
170 : : */
171 : : struct kernfs_syscall_ops {
172 : : int (*show_options)(struct seq_file *sf, struct kernfs_root *root);
173 : :
174 : : int (*mkdir)(struct kernfs_node *parent, const char *name,
175 : : umode_t mode);
176 : : int (*rmdir)(struct kernfs_node *kn);
177 : : int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent,
178 : : const char *new_name);
179 : : int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
180 : : struct kernfs_root *root);
181 : : };
182 : :
183 : : struct kernfs_root {
184 : : /* published fields */
185 : : struct kernfs_node *kn;
186 : : unsigned int flags; /* KERNFS_ROOT_* flags */
187 : :
188 : : /* private fields, do not use outside kernfs proper */
189 : : struct idr ino_idr;
190 : : u32 last_ino;
191 : : u32 next_generation;
192 : : struct kernfs_syscall_ops *syscall_ops;
193 : :
194 : : /* list of kernfs_super_info of this root, protected by kernfs_mutex */
195 : : struct list_head supers;
196 : :
197 : : wait_queue_head_t deactivate_waitq;
198 : : };
199 : :
200 : : struct kernfs_open_file {
201 : : /* published fields */
202 : : struct kernfs_node *kn;
203 : : struct file *file;
204 : : struct seq_file *seq_file;
205 : : void *priv;
206 : :
207 : : /* private fields, do not use outside kernfs proper */
208 : : struct mutex mutex;
209 : : struct mutex prealloc_mutex;
210 : : int event;
211 : : struct list_head list;
212 : : char *prealloc_buf;
213 : :
214 : : size_t atomic_write_len;
215 : : bool mmapped:1;
216 : : bool released:1;
217 : : const struct vm_operations_struct *vm_ops;
218 : : };
219 : :
220 : : struct kernfs_ops {
221 : : /*
222 : : * Optional open/release methods. Both are called with
223 : : * @of->seq_file populated.
224 : : */
225 : : int (*open)(struct kernfs_open_file *of);
226 : : void (*release)(struct kernfs_open_file *of);
227 : :
228 : : /*
229 : : * Read is handled by either seq_file or raw_read().
230 : : *
231 : : * If seq_show() is present, seq_file path is active. Other seq
232 : : * operations are optional and if not implemented, the behavior is
233 : : * equivalent to single_open(). @sf->private points to the
234 : : * associated kernfs_open_file.
235 : : *
236 : : * read() is bounced through kernel buffer and a read larger than
237 : : * PAGE_SIZE results in partial operation of PAGE_SIZE.
238 : : */
239 : : int (*seq_show)(struct seq_file *sf, void *v);
240 : :
241 : : void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
242 : : void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
243 : : void (*seq_stop)(struct seq_file *sf, void *v);
244 : :
245 : : ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
246 : : loff_t off);
247 : :
248 : : /*
249 : : * write() is bounced through kernel buffer. If atomic_write_len
250 : : * is not set, a write larger than PAGE_SIZE results in partial
251 : : * operations of PAGE_SIZE chunks. If atomic_write_len is set,
252 : : * writes upto the specified size are executed atomically but
253 : : * larger ones are rejected with -E2BIG.
254 : : */
255 : : size_t atomic_write_len;
256 : : /*
257 : : * "prealloc" causes a buffer to be allocated at open for
258 : : * all read/write requests. As ->seq_show uses seq_read()
259 : : * which does its own allocation, it is incompatible with
260 : : * ->prealloc. Provide ->read and ->write with ->prealloc.
261 : : */
262 : : bool prealloc;
263 : : ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
264 : : loff_t off);
265 : :
266 : : __poll_t (*poll)(struct kernfs_open_file *of,
267 : : struct poll_table_struct *pt);
268 : :
269 : : int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
270 : :
271 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
272 : : struct lock_class_key lockdep_key;
273 : : #endif
274 : : };
275 : :
276 : : /*
277 : : * The kernfs superblock creation/mount parameter context.
278 : : */
279 : : struct kernfs_fs_context {
280 : : struct kernfs_root *root; /* Root of the hierarchy being mounted */
281 : : void *ns_tag; /* Namespace tag of the mount (or NULL) */
282 : : unsigned long magic; /* File system specific magic number */
283 : :
284 : : /* The following are set/used by kernfs_mount() */
285 : : bool new_sb_created; /* Set to T if we allocated a new sb */
286 : : };
287 : :
288 : : #ifdef CONFIG_KERNFS
289 : :
290 : : static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
291 : : {
292 : 3 : return kn->flags & KERNFS_TYPE_MASK;
293 : : }
294 : :
295 : : /**
296 : : * kernfs_enable_ns - enable namespace under a directory
297 : : * @kn: directory of interest, should be empty
298 : : *
299 : : * This is to be called right after @kn is created to enable namespace
300 : : * under it. All children of @kn must have non-NULL namespace tags and
301 : : * only the ones which match the super_block's tag will be visible.
302 : : */
303 : 3 : static inline void kernfs_enable_ns(struct kernfs_node *kn)
304 : : {
305 : 3 : WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
306 : 3 : WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
307 : 3 : kn->flags |= KERNFS_NS;
308 : 3 : }
309 : :
310 : : /**
311 : : * kernfs_ns_enabled - test whether namespace is enabled
312 : : * @kn: the node to test
313 : : *
314 : : * Test whether namespace filtering is enabled for the children of @ns.
315 : : */
316 : : static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
317 : : {
318 : 3 : return kn->flags & KERNFS_NS;
319 : : }
320 : :
321 : : int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
322 : : int kernfs_path_from_node(struct kernfs_node *root_kn, struct kernfs_node *kn,
323 : : char *buf, size_t buflen);
324 : : void pr_cont_kernfs_name(struct kernfs_node *kn);
325 : : void pr_cont_kernfs_path(struct kernfs_node *kn);
326 : : struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
327 : : struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
328 : : const char *name, const void *ns);
329 : : struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
330 : : const char *path, const void *ns);
331 : : void kernfs_get(struct kernfs_node *kn);
332 : : void kernfs_put(struct kernfs_node *kn);
333 : :
334 : : struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
335 : : struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
336 : : struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
337 : :
338 : : struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
339 : : struct super_block *sb);
340 : : struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
341 : : unsigned int flags, void *priv);
342 : : void kernfs_destroy_root(struct kernfs_root *root);
343 : :
344 : : struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
345 : : const char *name, umode_t mode,
346 : : kuid_t uid, kgid_t gid,
347 : : void *priv, const void *ns);
348 : : struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
349 : : const char *name);
350 : : struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
351 : : const char *name, umode_t mode,
352 : : kuid_t uid, kgid_t gid,
353 : : loff_t size,
354 : : const struct kernfs_ops *ops,
355 : : void *priv, const void *ns,
356 : : struct lock_class_key *key);
357 : : struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
358 : : const char *name,
359 : : struct kernfs_node *target);
360 : : void kernfs_activate(struct kernfs_node *kn);
361 : : void kernfs_remove(struct kernfs_node *kn);
362 : : void kernfs_break_active_protection(struct kernfs_node *kn);
363 : : void kernfs_unbreak_active_protection(struct kernfs_node *kn);
364 : : bool kernfs_remove_self(struct kernfs_node *kn);
365 : : int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
366 : : const void *ns);
367 : : int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
368 : : const char *new_name, const void *new_ns);
369 : : int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
370 : : __poll_t kernfs_generic_poll(struct kernfs_open_file *of,
371 : : struct poll_table_struct *pt);
372 : : void kernfs_notify(struct kernfs_node *kn);
373 : :
374 : : int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
375 : : void *value, size_t size);
376 : : int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
377 : : const void *value, size_t size, int flags);
378 : :
379 : : const void *kernfs_super_ns(struct super_block *sb);
380 : : int kernfs_get_tree(struct fs_context *fc);
381 : : void kernfs_free_fs_context(struct fs_context *fc);
382 : : void kernfs_kill_sb(struct super_block *sb);
383 : :
384 : : void kernfs_init(void);
385 : :
386 : : struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root,
387 : : const union kernfs_node_id *id);
388 : : #else /* CONFIG_KERNFS */
389 : :
390 : : static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
391 : : { return 0; } /* whatever */
392 : :
393 : : static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
394 : :
395 : : static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
396 : : { return false; }
397 : :
398 : : static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
399 : : { return -ENOSYS; }
400 : :
401 : : static inline int kernfs_path_from_node(struct kernfs_node *root_kn,
402 : : struct kernfs_node *kn,
403 : : char *buf, size_t buflen)
404 : : { return -ENOSYS; }
405 : :
406 : : static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
407 : : static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }
408 : :
409 : : static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
410 : : { return NULL; }
411 : :
412 : : static inline struct kernfs_node *
413 : : kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
414 : : const void *ns)
415 : : { return NULL; }
416 : : static inline struct kernfs_node *
417 : : kernfs_walk_and_get_ns(struct kernfs_node *parent, const char *path,
418 : : const void *ns)
419 : : { return NULL; }
420 : :
421 : : static inline void kernfs_get(struct kernfs_node *kn) { }
422 : : static inline void kernfs_put(struct kernfs_node *kn) { }
423 : :
424 : : static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
425 : : { return NULL; }
426 : :
427 : : static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
428 : : { return NULL; }
429 : :
430 : : static inline struct inode *
431 : : kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
432 : : { return NULL; }
433 : :
434 : : static inline struct kernfs_root *
435 : : kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
436 : : void *priv)
437 : : { return ERR_PTR(-ENOSYS); }
438 : :
439 : : static inline void kernfs_destroy_root(struct kernfs_root *root) { }
440 : :
441 : : static inline struct kernfs_node *
442 : : kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
443 : : umode_t mode, kuid_t uid, kgid_t gid,
444 : : void *priv, const void *ns)
445 : : { return ERR_PTR(-ENOSYS); }
446 : :
447 : : static inline struct kernfs_node *
448 : : __kernfs_create_file(struct kernfs_node *parent, const char *name,
449 : : umode_t mode, kuid_t uid, kgid_t gid,
450 : : loff_t size, const struct kernfs_ops *ops,
451 : : void *priv, const void *ns, struct lock_class_key *key)
452 : : { return ERR_PTR(-ENOSYS); }
453 : :
454 : : static inline struct kernfs_node *
455 : : kernfs_create_link(struct kernfs_node *parent, const char *name,
456 : : struct kernfs_node *target)
457 : : { return ERR_PTR(-ENOSYS); }
458 : :
459 : : static inline void kernfs_activate(struct kernfs_node *kn) { }
460 : :
461 : : static inline void kernfs_remove(struct kernfs_node *kn) { }
462 : :
463 : : static inline bool kernfs_remove_self(struct kernfs_node *kn)
464 : : { return false; }
465 : :
466 : : static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
467 : : const char *name, const void *ns)
468 : : { return -ENOSYS; }
469 : :
470 : : static inline int kernfs_rename_ns(struct kernfs_node *kn,
471 : : struct kernfs_node *new_parent,
472 : : const char *new_name, const void *new_ns)
473 : : { return -ENOSYS; }
474 : :
475 : : static inline int kernfs_setattr(struct kernfs_node *kn,
476 : : const struct iattr *iattr)
477 : : { return -ENOSYS; }
478 : :
479 : : static inline void kernfs_notify(struct kernfs_node *kn) { }
480 : :
481 : : static inline int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
482 : : void *value, size_t size)
483 : : { return -ENOSYS; }
484 : :
485 : : static inline int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
486 : : const void *value, size_t size, int flags)
487 : : { return -ENOSYS; }
488 : :
489 : : static inline const void *kernfs_super_ns(struct super_block *sb)
490 : : { return NULL; }
491 : :
492 : : static inline int kernfs_get_tree(struct fs_context *fc)
493 : : { return -ENOSYS; }
494 : :
495 : : static inline void kernfs_free_fs_context(struct fs_context *fc) { }
496 : :
497 : : static inline void kernfs_kill_sb(struct super_block *sb) { }
498 : :
499 : : static inline void kernfs_init(void) { }
500 : :
501 : : #endif /* CONFIG_KERNFS */
502 : :
503 : : /**
504 : : * kernfs_path - build full path of a given node
505 : : * @kn: kernfs_node of interest
506 : : * @buf: buffer to copy @kn's name into
507 : : * @buflen: size of @buf
508 : : *
509 : : * If @kn is NULL result will be "(null)".
510 : : *
511 : : * Returns the length of the full path. If the full length is equal to or
512 : : * greater than @buflen, @buf contains the truncated path with the trailing
513 : : * '\0'. On error, -errno is returned.
514 : : */
515 : : static inline int kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen)
516 : : {
517 : 0 : return kernfs_path_from_node(kn, NULL, buf, buflen);
518 : : }
519 : :
520 : : static inline struct kernfs_node *
521 : : kernfs_find_and_get(struct kernfs_node *kn, const char *name)
522 : : {
523 : 3 : return kernfs_find_and_get_ns(kn, name, NULL);
524 : : }
525 : :
526 : : static inline struct kernfs_node *
527 : : kernfs_walk_and_get(struct kernfs_node *kn, const char *path)
528 : : {
529 : 0 : return kernfs_walk_and_get_ns(kn, path, NULL);
530 : : }
531 : :
532 : : static inline struct kernfs_node *
533 : : kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
534 : : void *priv)
535 : : {
536 : 3 : return kernfs_create_dir_ns(parent, name, mode,
537 : 3 : GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
538 : : priv, NULL);
539 : : }
540 : :
541 : : static inline struct kernfs_node *
542 : : kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
543 : : umode_t mode, kuid_t uid, kgid_t gid,
544 : : loff_t size, const struct kernfs_ops *ops,
545 : : void *priv, const void *ns)
546 : : {
547 : : struct lock_class_key *key = NULL;
548 : :
549 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
550 : : key = (struct lock_class_key *)&ops->lockdep_key;
551 : : #endif
552 : : return __kernfs_create_file(parent, name, mode, uid, gid,
553 : : size, ops, priv, ns, key);
554 : : }
555 : :
556 : : static inline struct kernfs_node *
557 : : kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
558 : : loff_t size, const struct kernfs_ops *ops, void *priv)
559 : : {
560 : : return kernfs_create_file_ns(parent, name, mode,
561 : : GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
562 : : size, ops, priv, NULL);
563 : : }
564 : :
565 : : static inline int kernfs_remove_by_name(struct kernfs_node *parent,
566 : : const char *name)
567 : : {
568 : 3 : return kernfs_remove_by_name_ns(parent, name, NULL);
569 : : }
570 : :
571 : : static inline int kernfs_rename(struct kernfs_node *kn,
572 : : struct kernfs_node *new_parent,
573 : : const char *new_name)
574 : : {
575 : 0 : return kernfs_rename_ns(kn, new_parent, new_name, NULL);
576 : : }
577 : :
578 : : #endif /* __LINUX_KERNFS_H */
|
