PageRenderTime 50ms CodeModel.GetById 19ms app.highlight 26ms RepoModel.GetById 0ms app.codeStats 0ms

/fs/sysfs/dir.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 964 lines | 588 code | 143 blank | 233 comment | 115 complexity | 1924cb58eb8b9bd7a553093af85bb2c4 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  1/*
  2 * fs/sysfs/dir.c - sysfs core and dir operation implementation
  3 *
  4 * Copyright (c) 2001-3 Patrick Mochel
  5 * Copyright (c) 2007 SUSE Linux Products GmbH
  6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
  7 *
  8 * This file is released under the GPLv2.
  9 *
 10 * Please see Documentation/filesystems/sysfs.txt for more information.
 11 */
 12
 13#undef DEBUG
 14
 15#include <linux/fs.h>
 16#include <linux/mount.h>
 17#include <linux/module.h>
 18#include <linux/kobject.h>
 19#include <linux/namei.h>
 20#include <linux/idr.h>
 21#include <linux/completion.h>
 22#include <linux/mutex.h>
 23#include <linux/slab.h>
 24#include <linux/security.h>
 25#include "sysfs.h"
 26
 27DEFINE_MUTEX(sysfs_mutex);
 28DEFINE_SPINLOCK(sysfs_assoc_lock);
 29
 30static DEFINE_SPINLOCK(sysfs_ino_lock);
 31static DEFINE_IDA(sysfs_ino_ida);
 32
 33/**
 34 *	sysfs_link_sibling - link sysfs_dirent into sibling list
 35 *	@sd: sysfs_dirent of interest
 36 *
 37 *	Link @sd into its sibling list which starts from
 38 *	sd->s_parent->s_dir.children.
 39 *
 40 *	Locking:
 41 *	mutex_lock(sysfs_mutex)
 42 */
 43static void sysfs_link_sibling(struct sysfs_dirent *sd)
 44{
 45	struct sysfs_dirent *parent_sd = sd->s_parent;
 46	struct sysfs_dirent **pos;
 47
 48	BUG_ON(sd->s_sibling);
 49
 50	/* Store directory entries in order by ino.  This allows
 51	 * readdir to properly restart without having to add a
 52	 * cursor into the s_dir.children list.
 53	 */
 54	for (pos = &parent_sd->s_dir.children; *pos; pos = &(*pos)->s_sibling) {
 55		if (sd->s_ino < (*pos)->s_ino)
 56			break;
 57	}
 58	sd->s_sibling = *pos;
 59	*pos = sd;
 60}
 61
 62/**
 63 *	sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
 64 *	@sd: sysfs_dirent of interest
 65 *
 66 *	Unlink @sd from its sibling list which starts from
 67 *	sd->s_parent->s_dir.children.
 68 *
 69 *	Locking:
 70 *	mutex_lock(sysfs_mutex)
 71 */
 72static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
 73{
 74	struct sysfs_dirent **pos;
 75
 76	for (pos = &sd->s_parent->s_dir.children; *pos;
 77	     pos = &(*pos)->s_sibling) {
 78		if (*pos == sd) {
 79			*pos = sd->s_sibling;
 80			sd->s_sibling = NULL;
 81			break;
 82		}
 83	}
 84}
 85
 86/**
 87 *	sysfs_get_active - get an active reference to sysfs_dirent
 88 *	@sd: sysfs_dirent to get an active reference to
 89 *
 90 *	Get an active reference of @sd.  This function is noop if @sd
 91 *	is NULL.
 92 *
 93 *	RETURNS:
 94 *	Pointer to @sd on success, NULL on failure.
 95 */
 96struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
 97{
 98	if (unlikely(!sd))
 99		return NULL;
100
101	while (1) {
102		int v, t;
103
104		v = atomic_read(&sd->s_active);
105		if (unlikely(v < 0))
106			return NULL;
107
108		t = atomic_cmpxchg(&sd->s_active, v, v + 1);
109		if (likely(t == v)) {
110			rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
111			return sd;
112		}
113		if (t < 0)
114			return NULL;
115
116		cpu_relax();
117	}
118}
119
120/**
121 *	sysfs_put_active - put an active reference to sysfs_dirent
122 *	@sd: sysfs_dirent to put an active reference to
123 *
124 *	Put an active reference to @sd.  This function is noop if @sd
125 *	is NULL.
126 */
127void sysfs_put_active(struct sysfs_dirent *sd)
128{
129	struct completion *cmpl;
130	int v;
131
132	if (unlikely(!sd))
133		return;
134
135	rwsem_release(&sd->dep_map, 1, _RET_IP_);
136	v = atomic_dec_return(&sd->s_active);
137	if (likely(v != SD_DEACTIVATED_BIAS))
138		return;
139
140	/* atomic_dec_return() is a mb(), we'll always see the updated
141	 * sd->s_sibling.
142	 */
143	cmpl = (void *)sd->s_sibling;
144	complete(cmpl);
145}
146
147/**
148 *	sysfs_deactivate - deactivate sysfs_dirent
149 *	@sd: sysfs_dirent to deactivate
150 *
151 *	Deny new active references and drain existing ones.
152 */
153static void sysfs_deactivate(struct sysfs_dirent *sd)
154{
155	DECLARE_COMPLETION_ONSTACK(wait);
156	int v;
157
158	BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
159
160	if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
161		return;
162
163	sd->s_sibling = (void *)&wait;
164
165	rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
166	/* atomic_add_return() is a mb(), put_active() will always see
167	 * the updated sd->s_sibling.
168	 */
169	v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
170
171	if (v != SD_DEACTIVATED_BIAS) {
172		lock_contended(&sd->dep_map, _RET_IP_);
173		wait_for_completion(&wait);
174	}
175
176	sd->s_sibling = NULL;
177
178	lock_acquired(&sd->dep_map, _RET_IP_);
179	rwsem_release(&sd->dep_map, 1, _RET_IP_);
180}
181
182static int sysfs_alloc_ino(ino_t *pino)
183{
184	int ino, rc;
185
186 retry:
187	spin_lock(&sysfs_ino_lock);
188	rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
189	spin_unlock(&sysfs_ino_lock);
190
191	if (rc == -EAGAIN) {
192		if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
193			goto retry;
194		rc = -ENOMEM;
195	}
196
197	*pino = ino;
198	return rc;
199}
200
201static void sysfs_free_ino(ino_t ino)
202{
203	spin_lock(&sysfs_ino_lock);
204	ida_remove(&sysfs_ino_ida, ino);
205	spin_unlock(&sysfs_ino_lock);
206}
207
208void release_sysfs_dirent(struct sysfs_dirent * sd)
209{
210	struct sysfs_dirent *parent_sd;
211
212 repeat:
213	/* Moving/renaming is always done while holding reference.
214	 * sd->s_parent won't change beneath us.
215	 */
216	parent_sd = sd->s_parent;
217
218	if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
219		sysfs_put(sd->s_symlink.target_sd);
220	if (sysfs_type(sd) & SYSFS_COPY_NAME)
221		kfree(sd->s_name);
222	if (sd->s_iattr && sd->s_iattr->ia_secdata)
223		security_release_secctx(sd->s_iattr->ia_secdata,
224					sd->s_iattr->ia_secdata_len);
225	kfree(sd->s_iattr);
226	sysfs_free_ino(sd->s_ino);
227	kmem_cache_free(sysfs_dir_cachep, sd);
228
229	sd = parent_sd;
230	if (sd && atomic_dec_and_test(&sd->s_count))
231		goto repeat;
232}
233
234static int sysfs_dentry_delete(const struct dentry *dentry)
235{
236	struct sysfs_dirent *sd = dentry->d_fsdata;
237	return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
238}
239
240static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
241{
242	struct sysfs_dirent *sd;
243	int is_dir;
244
245	if (nd->flags & LOOKUP_RCU)
246		return -ECHILD;
247
248	sd = dentry->d_fsdata;
249	mutex_lock(&sysfs_mutex);
250
251	/* The sysfs dirent has been deleted */
252	if (sd->s_flags & SYSFS_FLAG_REMOVED)
253		goto out_bad;
254
255	/* The sysfs dirent has been moved? */
256	if (dentry->d_parent->d_fsdata != sd->s_parent)
257		goto out_bad;
258
259	/* The sysfs dirent has been renamed */
260	if (strcmp(dentry->d_name.name, sd->s_name) != 0)
261		goto out_bad;
262
263	mutex_unlock(&sysfs_mutex);
264out_valid:
265	return 1;
266out_bad:
267	/* Remove the dentry from the dcache hashes.
268	 * If this is a deleted dentry we use d_drop instead of d_delete
269	 * so sysfs doesn't need to cope with negative dentries.
270	 *
271	 * If this is a dentry that has simply been renamed we
272	 * use d_drop to remove it from the dcache lookup on its
273	 * old parent.  If this dentry persists later when a lookup
274	 * is performed at its new name the dentry will be readded
275	 * to the dcache hashes.
276	 */
277	is_dir = (sysfs_type(sd) == SYSFS_DIR);
278	mutex_unlock(&sysfs_mutex);
279	if (is_dir) {
280		/* If we have submounts we must allow the vfs caches
281		 * to lie about the state of the filesystem to prevent
282		 * leaks and other nasty things.
283		 */
284		if (have_submounts(dentry))
285			goto out_valid;
286		shrink_dcache_parent(dentry);
287	}
288	d_drop(dentry);
289	return 0;
290}
291
292static void sysfs_dentry_iput(struct dentry *dentry, struct inode *inode)
293{
294	struct sysfs_dirent * sd = dentry->d_fsdata;
295
296	sysfs_put(sd);
297	iput(inode);
298}
299
300static const struct dentry_operations sysfs_dentry_ops = {
301	.d_revalidate	= sysfs_dentry_revalidate,
302	.d_delete	= sysfs_dentry_delete,
303	.d_iput		= sysfs_dentry_iput,
304};
305
306struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
307{
308	char *dup_name = NULL;
309	struct sysfs_dirent *sd;
310
311	if (type & SYSFS_COPY_NAME) {
312		name = dup_name = kstrdup(name, GFP_KERNEL);
313		if (!name)
314			return NULL;
315	}
316
317	sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
318	if (!sd)
319		goto err_out1;
320
321	if (sysfs_alloc_ino(&sd->s_ino))
322		goto err_out2;
323
324	atomic_set(&sd->s_count, 1);
325	atomic_set(&sd->s_active, 0);
326
327	sd->s_name = name;
328	sd->s_mode = mode;
329	sd->s_flags = type;
330
331	return sd;
332
333 err_out2:
334	kmem_cache_free(sysfs_dir_cachep, sd);
335 err_out1:
336	kfree(dup_name);
337	return NULL;
338}
339
340/**
341 *	sysfs_addrm_start - prepare for sysfs_dirent add/remove
342 *	@acxt: pointer to sysfs_addrm_cxt to be used
343 *	@parent_sd: parent sysfs_dirent
344 *
345 *	This function is called when the caller is about to add or
346 *	remove sysfs_dirent under @parent_sd.  This function acquires
347 *	sysfs_mutex.  @acxt is used to keep and pass context to
348 *	other addrm functions.
349 *
350 *	LOCKING:
351 *	Kernel thread context (may sleep).  sysfs_mutex is locked on
352 *	return.
353 */
354void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
355		       struct sysfs_dirent *parent_sd)
356{
357	memset(acxt, 0, sizeof(*acxt));
358	acxt->parent_sd = parent_sd;
359
360	mutex_lock(&sysfs_mutex);
361}
362
363/**
364 *	__sysfs_add_one - add sysfs_dirent to parent without warning
365 *	@acxt: addrm context to use
366 *	@sd: sysfs_dirent to be added
367 *
368 *	Get @acxt->parent_sd and set sd->s_parent to it and increment
369 *	nlink of parent inode if @sd is a directory and link into the
370 *	children list of the parent.
371 *
372 *	This function should be called between calls to
373 *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
374 *	passed the same @acxt as passed to sysfs_addrm_start().
375 *
376 *	LOCKING:
377 *	Determined by sysfs_addrm_start().
378 *
379 *	RETURNS:
380 *	0 on success, -EEXIST if entry with the given name already
381 *	exists.
382 */
383int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
384{
385	struct sysfs_inode_attrs *ps_iattr;
386
387	if (sysfs_find_dirent(acxt->parent_sd, sd->s_ns, sd->s_name))
388		return -EEXIST;
389
390	sd->s_parent = sysfs_get(acxt->parent_sd);
391
392	sysfs_link_sibling(sd);
393
394	/* Update timestamps on the parent */
395	ps_iattr = acxt->parent_sd->s_iattr;
396	if (ps_iattr) {
397		struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
398		ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
399	}
400
401	return 0;
402}
403
404/**
405 *	sysfs_pathname - return full path to sysfs dirent
406 *	@sd: sysfs_dirent whose path we want
407 *	@path: caller allocated buffer
408 *
409 *	Gives the name "/" to the sysfs_root entry; any path returned
410 *	is relative to wherever sysfs is mounted.
411 *
412 *	XXX: does no error checking on @path size
413 */
414static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
415{
416	if (sd->s_parent) {
417		sysfs_pathname(sd->s_parent, path);
418		strcat(path, "/");
419	}
420	strcat(path, sd->s_name);
421	return path;
422}
423
424/**
425 *	sysfs_add_one - add sysfs_dirent to parent
426 *	@acxt: addrm context to use
427 *	@sd: sysfs_dirent to be added
428 *
429 *	Get @acxt->parent_sd and set sd->s_parent to it and increment
430 *	nlink of parent inode if @sd is a directory and link into the
431 *	children list of the parent.
432 *
433 *	This function should be called between calls to
434 *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
435 *	passed the same @acxt as passed to sysfs_addrm_start().
436 *
437 *	LOCKING:
438 *	Determined by sysfs_addrm_start().
439 *
440 *	RETURNS:
441 *	0 on success, -EEXIST if entry with the given name already
442 *	exists.
443 */
444int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
445{
446	int ret;
447
448	ret = __sysfs_add_one(acxt, sd);
449	if (ret == -EEXIST) {
450		char *path = kzalloc(PATH_MAX, GFP_KERNEL);
451		WARN(1, KERN_WARNING
452		     "sysfs: cannot create duplicate filename '%s'\n",
453		     (path == NULL) ? sd->s_name :
454		     strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
455		            sd->s_name));
456		kfree(path);
457	}
458
459	return ret;
460}
461
462/**
463 *	sysfs_remove_one - remove sysfs_dirent from parent
464 *	@acxt: addrm context to use
465 *	@sd: sysfs_dirent to be removed
466 *
467 *	Mark @sd removed and drop nlink of parent inode if @sd is a
468 *	directory.  @sd is unlinked from the children list.
469 *
470 *	This function should be called between calls to
471 *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
472 *	passed the same @acxt as passed to sysfs_addrm_start().
473 *
474 *	LOCKING:
475 *	Determined by sysfs_addrm_start().
476 */
477void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
478{
479	struct sysfs_inode_attrs *ps_iattr;
480
481	BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
482
483	sysfs_unlink_sibling(sd);
484
485	/* Update timestamps on the parent */
486	ps_iattr = acxt->parent_sd->s_iattr;
487	if (ps_iattr) {
488		struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
489		ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
490	}
491
492	sd->s_flags |= SYSFS_FLAG_REMOVED;
493	sd->s_sibling = acxt->removed;
494	acxt->removed = sd;
495}
496
497/**
498 *	sysfs_addrm_finish - finish up sysfs_dirent add/remove
499 *	@acxt: addrm context to finish up
500 *
501 *	Finish up sysfs_dirent add/remove.  Resources acquired by
502 *	sysfs_addrm_start() are released and removed sysfs_dirents are
503 *	cleaned up.
504 *
505 *	LOCKING:
506 *	sysfs_mutex is released.
507 */
508void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
509{
510	/* release resources acquired by sysfs_addrm_start() */
511	mutex_unlock(&sysfs_mutex);
512
513	/* kill removed sysfs_dirents */
514	while (acxt->removed) {
515		struct sysfs_dirent *sd = acxt->removed;
516
517		acxt->removed = sd->s_sibling;
518		sd->s_sibling = NULL;
519
520		sysfs_deactivate(sd);
521		unmap_bin_file(sd);
522		sysfs_put(sd);
523	}
524}
525
526/**
527 *	sysfs_find_dirent - find sysfs_dirent with the given name
528 *	@parent_sd: sysfs_dirent to search under
529 *	@name: name to look for
530 *
531 *	Look for sysfs_dirent with name @name under @parent_sd.
532 *
533 *	LOCKING:
534 *	mutex_lock(sysfs_mutex)
535 *
536 *	RETURNS:
537 *	Pointer to sysfs_dirent if found, NULL if not.
538 */
539struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
540				       const void *ns,
541				       const unsigned char *name)
542{
543	struct sysfs_dirent *sd;
544
545	for (sd = parent_sd->s_dir.children; sd; sd = sd->s_sibling) {
546		if (ns && sd->s_ns && (sd->s_ns != ns))
547			continue;
548		if (!strcmp(sd->s_name, name))
549			return sd;
550	}
551	return NULL;
552}
553
554/**
555 *	sysfs_get_dirent - find and get sysfs_dirent with the given name
556 *	@parent_sd: sysfs_dirent to search under
557 *	@name: name to look for
558 *
559 *	Look for sysfs_dirent with name @name under @parent_sd and get
560 *	it if found.
561 *
562 *	LOCKING:
563 *	Kernel thread context (may sleep).  Grabs sysfs_mutex.
564 *
565 *	RETURNS:
566 *	Pointer to sysfs_dirent if found, NULL if not.
567 */
568struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
569				      const void *ns,
570				      const unsigned char *name)
571{
572	struct sysfs_dirent *sd;
573
574	mutex_lock(&sysfs_mutex);
575	sd = sysfs_find_dirent(parent_sd, ns, name);
576	sysfs_get(sd);
577	mutex_unlock(&sysfs_mutex);
578
579	return sd;
580}
581EXPORT_SYMBOL_GPL(sysfs_get_dirent);
582
583static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
584	enum kobj_ns_type type, const void *ns, const char *name,
585	struct sysfs_dirent **p_sd)
586{
587	umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
588	struct sysfs_addrm_cxt acxt;
589	struct sysfs_dirent *sd;
590	int rc;
591
592	/* allocate */
593	sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
594	if (!sd)
595		return -ENOMEM;
596
597	sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
598	sd->s_ns = ns;
599	sd->s_dir.kobj = kobj;
600
601	/* link in */
602	sysfs_addrm_start(&acxt, parent_sd);
603	rc = sysfs_add_one(&acxt, sd);
604	sysfs_addrm_finish(&acxt);
605
606	if (rc == 0)
607		*p_sd = sd;
608	else
609		sysfs_put(sd);
610
611	return rc;
612}
613
614int sysfs_create_subdir(struct kobject *kobj, const char *name,
615			struct sysfs_dirent **p_sd)
616{
617	return create_dir(kobj, kobj->sd,
618			  KOBJ_NS_TYPE_NONE, NULL, name, p_sd);
619}
620
621/**
622 *	sysfs_read_ns_type: return associated ns_type
623 *	@kobj: the kobject being queried
624 *
625 *	Each kobject can be tagged with exactly one namespace type
626 *	(i.e. network or user).  Return the ns_type associated with
627 *	this object if any
628 */
629static enum kobj_ns_type sysfs_read_ns_type(struct kobject *kobj)
630{
631	const struct kobj_ns_type_operations *ops;
632	enum kobj_ns_type type;
633
634	ops = kobj_child_ns_ops(kobj);
635	if (!ops)
636		return KOBJ_NS_TYPE_NONE;
637
638	type = ops->type;
639	BUG_ON(type <= KOBJ_NS_TYPE_NONE);
640	BUG_ON(type >= KOBJ_NS_TYPES);
641	BUG_ON(!kobj_ns_type_registered(type));
642
643	return type;
644}
645
646/**
647 *	sysfs_create_dir - create a directory for an object.
648 *	@kobj:		object we're creating directory for. 
649 */
650int sysfs_create_dir(struct kobject * kobj)
651{
652	enum kobj_ns_type type;
653	struct sysfs_dirent *parent_sd, *sd;
654	const void *ns = NULL;
655	int error = 0;
656
657	BUG_ON(!kobj);
658
659	if (kobj->parent)
660		parent_sd = kobj->parent->sd;
661	else
662		parent_sd = &sysfs_root;
663
664	if (sysfs_ns_type(parent_sd))
665		ns = kobj->ktype->namespace(kobj);
666	type = sysfs_read_ns_type(kobj);
667
668	error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
669	if (!error)
670		kobj->sd = sd;
671	return error;
672}
673
674static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
675				struct nameidata *nd)
676{
677	struct dentry *ret = NULL;
678	struct dentry *parent = dentry->d_parent;
679	struct sysfs_dirent *parent_sd = parent->d_fsdata;
680	struct sysfs_dirent *sd;
681	struct inode *inode;
682	enum kobj_ns_type type;
683	const void *ns;
684
685	mutex_lock(&sysfs_mutex);
686
687	type = sysfs_ns_type(parent_sd);
688	ns = sysfs_info(dir->i_sb)->ns[type];
689
690	sd = sysfs_find_dirent(parent_sd, ns, dentry->d_name.name);
691
692	/* no such entry */
693	if (!sd) {
694		ret = ERR_PTR(-ENOENT);
695		goto out_unlock;
696	}
697
698	/* attach dentry and inode */
699	inode = sysfs_get_inode(dir->i_sb, sd);
700	if (!inode) {
701		ret = ERR_PTR(-ENOMEM);
702		goto out_unlock;
703	}
704
705	/* instantiate and hash dentry */
706	ret = d_find_alias(inode);
707	if (!ret) {
708		d_set_d_op(dentry, &sysfs_dentry_ops);
709		dentry->d_fsdata = sysfs_get(sd);
710		d_add(dentry, inode);
711	} else {
712		d_move(ret, dentry);
713		iput(inode);
714	}
715
716 out_unlock:
717	mutex_unlock(&sysfs_mutex);
718	return ret;
719}
720
721const struct inode_operations sysfs_dir_inode_operations = {
722	.lookup		= sysfs_lookup,
723	.permission	= sysfs_permission,
724	.setattr	= sysfs_setattr,
725	.getattr	= sysfs_getattr,
726	.setxattr	= sysfs_setxattr,
727};
728
729static void remove_dir(struct sysfs_dirent *sd)
730{
731	struct sysfs_addrm_cxt acxt;
732
733	sysfs_addrm_start(&acxt, sd->s_parent);
734	sysfs_remove_one(&acxt, sd);
735	sysfs_addrm_finish(&acxt);
736}
737
738void sysfs_remove_subdir(struct sysfs_dirent *sd)
739{
740	remove_dir(sd);
741}
742
743
744static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
745{
746	struct sysfs_addrm_cxt acxt;
747	struct sysfs_dirent **pos;
748
749	if (!dir_sd)
750		return;
751
752	pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
753	sysfs_addrm_start(&acxt, dir_sd);
754	pos = &dir_sd->s_dir.children;
755	while (*pos) {
756		struct sysfs_dirent *sd = *pos;
757
758		if (sysfs_type(sd) != SYSFS_DIR)
759			sysfs_remove_one(&acxt, sd);
760		else
761			pos = &(*pos)->s_sibling;
762	}
763	sysfs_addrm_finish(&acxt);
764
765	remove_dir(dir_sd);
766}
767
768/**
769 *	sysfs_remove_dir - remove an object's directory.
770 *	@kobj:	object.
771 *
772 *	The only thing special about this is that we remove any files in
773 *	the directory before we remove the directory, and we've inlined
774 *	what used to be sysfs_rmdir() below, instead of calling separately.
775 */
776
777void sysfs_remove_dir(struct kobject * kobj)
778{
779	struct sysfs_dirent *sd = kobj->sd;
780
781	spin_lock(&sysfs_assoc_lock);
782	kobj->sd = NULL;
783	spin_unlock(&sysfs_assoc_lock);
784
785	__sysfs_remove_dir(sd);
786}
787
788int sysfs_rename(struct sysfs_dirent *sd,
789	struct sysfs_dirent *new_parent_sd, const void *new_ns,
790	const char *new_name)
791{
792	const char *dup_name = NULL;
793	int error;
794
795	mutex_lock(&sysfs_mutex);
796
797	error = 0;
798	if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
799	    (strcmp(sd->s_name, new_name) == 0))
800		goto out;	/* nothing to rename */
801
802	error = -EEXIST;
803	if (sysfs_find_dirent(new_parent_sd, new_ns, new_name))
804		goto out;
805
806	/* rename sysfs_dirent */
807	if (strcmp(sd->s_name, new_name) != 0) {
808		error = -ENOMEM;
809		new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
810		if (!new_name)
811			goto out;
812
813		dup_name = sd->s_name;
814		sd->s_name = new_name;
815	}
816
817	/* Remove from old parent's list and insert into new parent's list. */
818	if (sd->s_parent != new_parent_sd) {
819		sysfs_unlink_sibling(sd);
820		sysfs_get(new_parent_sd);
821		sysfs_put(sd->s_parent);
822		sd->s_parent = new_parent_sd;
823		sysfs_link_sibling(sd);
824	}
825	sd->s_ns = new_ns;
826
827	error = 0;
828 out:
829	mutex_unlock(&sysfs_mutex);
830	kfree(dup_name);
831	return error;
832}
833
834int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
835{
836	struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
837	const void *new_ns = NULL;
838
839	if (sysfs_ns_type(parent_sd))
840		new_ns = kobj->ktype->namespace(kobj);
841
842	return sysfs_rename(kobj->sd, parent_sd, new_ns, new_name);
843}
844
845int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
846{
847	struct sysfs_dirent *sd = kobj->sd;
848	struct sysfs_dirent *new_parent_sd;
849	const void *new_ns = NULL;
850
851	BUG_ON(!sd->s_parent);
852	if (sysfs_ns_type(sd->s_parent))
853		new_ns = kobj->ktype->namespace(kobj);
854	new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
855		new_parent_kobj->sd : &sysfs_root;
856
857	return sysfs_rename(sd, new_parent_sd, new_ns, sd->s_name);
858}
859
860/* Relationship between s_mode and the DT_xxx types */
861static inline unsigned char dt_type(struct sysfs_dirent *sd)
862{
863	return (sd->s_mode >> 12) & 15;
864}
865
866static int sysfs_dir_release(struct inode *inode, struct file *filp)
867{
868	sysfs_put(filp->private_data);
869	return 0;
870}
871
872static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
873	struct sysfs_dirent *parent_sd,	ino_t ino, struct sysfs_dirent *pos)
874{
875	if (pos) {
876		int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
877			pos->s_parent == parent_sd &&
878			ino == pos->s_ino;
879		sysfs_put(pos);
880		if (!valid)
881			pos = NULL;
882	}
883	if (!pos && (ino > 1) && (ino < INT_MAX)) {
884		pos = parent_sd->s_dir.children;
885		while (pos && (ino > pos->s_ino))
886			pos = pos->s_sibling;
887	}
888	while (pos && pos->s_ns && pos->s_ns != ns)
889		pos = pos->s_sibling;
890	return pos;
891}
892
893static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
894	struct sysfs_dirent *parent_sd,	ino_t ino, struct sysfs_dirent *pos)
895{
896	pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
897	if (pos)
898		pos = pos->s_sibling;
899	while (pos && pos->s_ns && pos->s_ns != ns)
900		pos = pos->s_sibling;
901	return pos;
902}
903
904static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
905{
906	struct dentry *dentry = filp->f_path.dentry;
907	struct sysfs_dirent * parent_sd = dentry->d_fsdata;
908	struct sysfs_dirent *pos = filp->private_data;
909	enum kobj_ns_type type;
910	const void *ns;
911	ino_t ino;
912
913	type = sysfs_ns_type(parent_sd);
914	ns = sysfs_info(dentry->d_sb)->ns[type];
915
916	if (filp->f_pos == 0) {
917		ino = parent_sd->s_ino;
918		if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
919			filp->f_pos++;
920	}
921	if (filp->f_pos == 1) {
922		if (parent_sd->s_parent)
923			ino = parent_sd->s_parent->s_ino;
924		else
925			ino = parent_sd->s_ino;
926		if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
927			filp->f_pos++;
928	}
929	mutex_lock(&sysfs_mutex);
930	for (pos = sysfs_dir_pos(ns, parent_sd, filp->f_pos, pos);
931	     pos;
932	     pos = sysfs_dir_next_pos(ns, parent_sd, filp->f_pos, pos)) {
933		const char * name;
934		unsigned int type;
935		int len, ret;
936
937		name = pos->s_name;
938		len = strlen(name);
939		ino = pos->s_ino;
940		type = dt_type(pos);
941		filp->f_pos = ino;
942		filp->private_data = sysfs_get(pos);
943
944		mutex_unlock(&sysfs_mutex);
945		ret = filldir(dirent, name, len, filp->f_pos, ino, type);
946		mutex_lock(&sysfs_mutex);
947		if (ret < 0)
948			break;
949	}
950	mutex_unlock(&sysfs_mutex);
951	if ((filp->f_pos > 1) && !pos) { /* EOF */
952		filp->f_pos = INT_MAX;
953		filp->private_data = NULL;
954	}
955	return 0;
956}
957
958
959const struct file_operations sysfs_dir_operations = {
960	.read		= generic_read_dir,
961	.readdir	= sysfs_readdir,
962	.release	= sysfs_dir_release,
963	.llseek		= generic_file_llseek,
964};