// SPDX-License-Identifier: GPL-2.0

  /*

   * fs/sysfs/dir.c - sysfs core and dir operation implementation
   *
   * Copyright (c) 2001-3 Patrick Mochel
   * Copyright (c) 2007 SUSE Linux Products GmbH
   * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
   *

   * Please see Documentation/filesystems/sysfs.rst for more information.

   */

  #define pr_fmt(fmt)	"sysfs: " fmt

  
  #include <linux/fs.h>

  #include <linux/kobject.h>

  #include <linux/slab.h>

  #include "sysfs.h"

  DEFINE_SPINLOCK(sysfs_symlink_target_lock);

  void sysfs_warn_dup(struct kernfs_node *parent, const char *name)

  {

  	char *buf;

  	buf = kzalloc(PATH_MAX, GFP_KERNEL);
  	if (buf)

  		kernfs_path(parent, buf, PATH_MAX);

  	pr_warn("cannot create duplicate filename '%s/%s'
  ", buf, name);
  	dump_stack();

  	kfree(buf);

  }

  /**

   * sysfs_create_dir_ns - create a directory for an object with a namespace tag
   * @kobj: object we're creating directory for
   * @ns: the namespace tag to use

   */

  int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)

  {

  	struct kernfs_node *parent, *kn;

  	kuid_t uid;
  	kgid_t gid;

  	if (WARN_ON(!kobj))
  		return -EINVAL;

  	if (kobj->parent)

  		parent = kobj->parent->sd;

  	else

  		parent = sysfs_root_kn;

  	if (!parent)

  		return -ENOENT;

  	kobject_get_ownership(kobj, &uid, &gid);

  	kn = kernfs_create_dir_ns(parent, kobject_name(kobj),

  				  S_IRWXU | S_IRUGO | S_IXUGO, uid, gid,

  				  kobj, ns);

  	if (IS_ERR(kn)) {
  		if (PTR_ERR(kn) == -EEXIST)
  			sysfs_warn_dup(parent, kobject_name(kobj));
  		return PTR_ERR(kn);

  	}

  	kobj->sd = kn;

  	return 0;

  }

  /**

   *	sysfs_remove_dir - remove an object's directory.
   *	@kobj:	object.
   *
   *	The only thing special about this is that we remove any files in
   *	the directory before we remove the directory, and we've inlined
   *	what used to be sysfs_rmdir() below, instead of calling separately.
   */

  void sysfs_remove_dir(struct kobject *kobj)

  {

  	struct kernfs_node *kn = kobj->sd;

  	/*
  	 * In general, kboject owner is responsible for ensuring removal
  	 * doesn't race with other operations and sysfs doesn't provide any
  	 * protection; however, when @kobj is used as a symlink target, the
  	 * symlinking entity usually doesn't own @kobj and thus has no

  	 * control over removal.  @kobj->sd may be removed anytime
  	 * and symlink code may end up dereferencing an already freed node.

  	 *

  	 * sysfs_symlink_target_lock synchronizes @kobj->sd
  	 * disassociation against symlink operations so that symlink code
  	 * can safely dereference @kobj->sd.

  	 */
  	spin_lock(&sysfs_symlink_target_lock);

  	kobj->sd = NULL;

  	spin_unlock(&sysfs_symlink_target_lock);

  	if (kn) {

  		WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);

  		kernfs_remove(kn);

  	}

  }

  int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
  			const void *new_ns)

  {

  	struct kernfs_node *parent;
  	int ret;

  	parent = kernfs_get_parent(kobj->sd);
  	ret = kernfs_rename_ns(kobj->sd, parent, new_name, new_ns);
  	kernfs_put(parent);
  	return ret;

  }

  int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj,
  		      const void *new_ns)

  {

  	struct kernfs_node *kn = kobj->sd;
  	struct kernfs_node *new_parent;

  	new_parent = new_parent_kobj && new_parent_kobj->sd ?
  		new_parent_kobj->sd : sysfs_root_kn;

  	return kernfs_rename_ns(kn, new_parent, kn->name, new_ns);

  }

  
  /**
   * sysfs_create_mount_point - create an always empty directory
   * @parent_kobj:  kobject that will contain this always empty directory
   * @name: The name of the always empty directory to add
   */
  int sysfs_create_mount_point(struct kobject *parent_kobj, const char *name)
  {
  	struct kernfs_node *kn, *parent = parent_kobj->sd;
  
  	kn = kernfs_create_empty_dir(parent, name);
  	if (IS_ERR(kn)) {
  		if (PTR_ERR(kn) == -EEXIST)
  			sysfs_warn_dup(parent, name);
  		return PTR_ERR(kn);
  	}
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(sysfs_create_mount_point);
  
  /**
   *	sysfs_remove_mount_point - remove an always empty directory.
   *	@parent_kobj: kobject that will contain this always empty directory
   *	@name: The name of the always empty directory to remove
   *
   */
  void sysfs_remove_mount_point(struct kobject *parent_kobj, const char *name)
  {
  	struct kernfs_node *parent = parent_kobj->sd;
  
  	kernfs_remove_by_name_ns(parent, name, NULL);
  }
  EXPORT_SYMBOL_GPL(sysfs_remove_mount_point);