Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 1cc523271ef0b6305c565a143e3d48f6fff826dd

Authored by stephen hemminger 2010-02-22 15:57:17 +0800

Committed by David S. Miller 2010-02-23 07:45:54 +0800

Exists in master and in 7 other branches

seq_file: add RCU versions of new hlist/list iterators (v3)

Many usages of seq_file use RCU protected lists, so non RCU
iterators will not work safely.

Signed-off-by: Stephen Hemminger <shemminger@vyatta.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 3 changed files with 87 additions and 4 deletions Inline Diff

fs/seq_file.c
include/linux/rculist.h
include/linux/seq_file.h

fs/seq_file.c

Diff comments View file @ 1cc5232

 /*
  * linux/fs/seq_file.c
  *
  * helper functions for making synthetic files from sequences of records.
  * initial implementation -- AV, Oct 2001.
  */
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <asm/page.h>
 /**
  *	seq_open -	initialize sequential file
  *	@file: file we initialize
  *	@op: method table describing the sequence
  *
  *	seq_open() sets @file, associating it with a sequence described
  *	by @op.  @op->start() sets the iterator up and returns the first
  *	element of sequence. @op->stop() shuts it down.  @op->next()
  *	returns the next element of sequence.  @op->show() prints element
  *	into the buffer.  In case of error ->start() and ->next() return
  *	ERR_PTR(error).  In the end of sequence they return %NULL. ->show()
  *	returns 0 in case of success and negative number in case of error.
  *	Returning SEQ_SKIP means "discard this element and move on".
  */
 int seq_open(struct file *file, const struct seq_operations *op)
 {
 	struct seq_file *p = file->private_data;
 	if (!p) {
 		p = kmalloc(sizeof(*p), GFP_KERNEL);
 		if (!p)
 			return -ENOMEM;
 		file->private_data = p;
 	}
 	memset(p, 0, sizeof(*p));
 	mutex_init(&p->lock);
 	p->op = op;
 	/*
 	 * Wrappers around seq_open(e.g. swaps_open) need to be
 	 * aware of this. If they set f_version themselves, they
 	 * should call seq_open first and then set f_version.
 	 */
 	file->f_version = 0;
 	/*
 	 * seq_files support lseek() and pread().  They do not implement
 	 * write() at all, but we clear FMODE_PWRITE here for historical
 	 * reasons.
 	 *
 	 * If a client of seq_files a) implements file.write() and b) wishes to
 	 * support pwrite() then that client will need to implement its own
 	 * file.open() which calls seq_open() and then sets FMODE_PWRITE.
 	 */
 	file->f_mode &= ~FMODE_PWRITE;
 	return 0;
 }
 EXPORT_SYMBOL(seq_open);
 static int traverse(struct seq_file *m, loff_t offset)
 {
 	loff_t pos = 0, index;
 	int error = 0;
 	void *p;
 	m->version = 0;
 	index = 0;
 	m->count = m->from = 0;
 	if (!offset) {
 		m->index = index;
 		return 0;
 	}
 	if (!m->buf) {
 		m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
 		if (!m->buf)
 			return -ENOMEM;
 	}
 	p = m->op->start(m, &index);
 	while (p) {
 		error = PTR_ERR(p);
 		if (IS_ERR(p))
 			break;
 		error = m->op->show(m, p);
 		if (error < 0)
 			break;
 		if (unlikely(error)) {
 			error = 0;
 			m->count = 0;
 		}
 		if (m->count == m->size)
 			goto Eoverflow;
 		if (pos + m->count > offset) {
 			m->from = offset - pos;
 			m->count -= m->from;
 			m->index = index;
 			break;
 		}
 		pos += m->count;
 		m->count = 0;
 		if (pos == offset) {
 			index++;
 			m->index = index;
 			break;
 		}
 		p = m->op->next(m, p, &index);
 	}
 	m->op->stop(m, p);
 	m->index = index;
 	return error;
 Eoverflow:
 	m->op->stop(m, p);
 	kfree(m->buf);
 	m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
 	return !m->buf ? -ENOMEM : -EAGAIN;
 }
 /**
  *	seq_read -	->read() method for sequential files.
  *	@file: the file to read from
  *	@buf: the buffer to read to
  *	@size: the maximum number of bytes to read
  *	@ppos: the current position in the file
  *
  *	Ready-made ->f_op->read()
  */
 ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 {
 	struct seq_file *m = (struct seq_file *)file->private_data;
 	size_t copied = 0;
 	loff_t pos;
 	size_t n;
 	void *p;
 	int err = 0;
 	mutex_lock(&m->lock);
 	/* Don't assume *ppos is where we left it */
 	if (unlikely(*ppos != m->read_pos)) {
 		m->read_pos = *ppos;
 		while ((err = traverse(m, *ppos)) == -EAGAIN)
 			;
 		if (err) {
 			/* With prejudice... */
 			m->read_pos = 0;
 			m->version = 0;
 			m->index = 0;
 			m->count = 0;
 			goto Done;
 		}
 	}
 	/*
 	 * seq_file->op->..m_start/m_stop/m_next may do special actions
 	 * or optimisations based on the file->f_version, so we want to
 	 * pass the file->f_version to those methods.
 	 *
 	 * seq_file->version is just copy of f_version, and seq_file
 	 * methods can treat it simply as file version.
 	 * It is copied in first and copied out after all operations.
 	 * It is convenient to have it as  part of structure to avoid the
 	 * need of passing another argument to all the seq_file methods.
 	 */
 	m->version = file->f_version;
 	/* grab buffer if we didn't have one */
 	if (!m->buf) {
 		m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
 		if (!m->buf)
 			goto Enomem;
 	}
 	/* if not empty - flush it first */
 	if (m->count) {
 		n = min(m->count, size);
 		err = copy_to_user(buf, m->buf + m->from, n);
 		if (err)
 			goto Efault;
 		m->count -= n;
 		m->from += n;
 		size -= n;
 		buf += n;
 		copied += n;
 		if (!m->count)
 			m->index++;
 		if (!size)
 			goto Done;
 	}
 	/* we need at least one record in buffer */
 	pos = m->index;
 	p = m->op->start(m, &pos);
 	while (1) {
 		err = PTR_ERR(p);
 		if (!p || IS_ERR(p))
 			break;
 		err = m->op->show(m, p);
 		if (err < 0)
 			break;
 		if (unlikely(err))
 			m->count = 0;
 		if (unlikely(!m->count)) {
 			p = m->op->next(m, p, &pos);
 			m->index = pos;
 			continue;
 		}
 		if (m->count < m->size)
 			goto Fill;
 		m->op->stop(m, p);
 		kfree(m->buf);
 		m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);
 		if (!m->buf)
 			goto Enomem;
 		m->count = 0;
 		m->version = 0;
 		pos = m->index;
 		p = m->op->start(m, &pos);
 	}
 	m->op->stop(m, p);
 	m->count = 0;
 	goto Done;
 Fill:
 	/* they want more? let's try to get some more */
 	while (m->count < size) {
 		size_t offs = m->count;
 		loff_t next = pos;
 		p = m->op->next(m, p, &next);
 		if (!p || IS_ERR(p)) {
 			err = PTR_ERR(p);
 			break;
 		}
 		err = m->op->show(m, p);
 		if (m->count == m->size || err) {
 			m->count = offs;
 			if (likely(err <= 0))
 				break;
 		}
 		pos = next;
 	}
 	m->op->stop(m, p);
 	n = min(m->count, size);
 	err = copy_to_user(buf, m->buf, n);
 	if (err)
 		goto Efault;
 	copied += n;
 	m->count -= n;
 	if (m->count)
 		m->from = n;
 	else
 		pos++;
 	m->index = pos;
 Done:
 	if (!copied)
 		copied = err;
 	else {
 		*ppos += copied;
 		m->read_pos += copied;
 	}
 	file->f_version = m->version;
 	mutex_unlock(&m->lock);
 	return copied;
 Enomem:
 	err = -ENOMEM;
 	goto Done;
 Efault:
 	err = -EFAULT;
 	goto Done;
 }
 EXPORT_SYMBOL(seq_read);
 /**
  *	seq_lseek -	->llseek() method for sequential files.
  *	@file: the file in question
  *	@offset: new position
  *	@origin: 0 for absolute, 1 for relative position
  *
  *	Ready-made ->f_op->llseek()
  */
 loff_t seq_lseek(struct file *file, loff_t offset, int origin)
 {
 	struct seq_file *m = (struct seq_file *)file->private_data;
 	loff_t retval = -EINVAL;
 	mutex_lock(&m->lock);
 	m->version = file->f_version;
 	switch (origin) {
 		case 1:
 			offset += file->f_pos;
 		case 0:
 			if (offset < 0)
 				break;
 			retval = offset;
 			if (offset != m->read_pos) {
 				while ((retval=traverse(m, offset)) == -EAGAIN)
 					;
 				if (retval) {
 					/* with extreme prejudice... */
 					file->f_pos = 0;
 					m->read_pos = 0;
 					m->version = 0;
 					m->index = 0;
 					m->count = 0;
 				} else {
 					m->read_pos = offset;
 					retval = file->f_pos = offset;
 				}
 			}
 	}
 	file->f_version = m->version;
 	mutex_unlock(&m->lock);
 	return retval;
 }
 EXPORT_SYMBOL(seq_lseek);
 /**
  *	seq_release -	free the structures associated with sequential file.
  *	@file: file in question
  *	@inode: file->f_path.dentry->d_inode
  *
  *	Frees the structures associated with sequential file; can be used
  *	as ->f_op->release() if you don't have private data to destroy.
  */
 int seq_release(struct inode *inode, struct file *file)
 {
 	struct seq_file *m = (struct seq_file *)file->private_data;
 	kfree(m->buf);
 	kfree(m);
 	return 0;
 }
 EXPORT_SYMBOL(seq_release);
 /**
  *	seq_escape -	print string into buffer, escaping some characters
  *	@m:	target buffer
  *	@s:	string
  *	@esc:	set of characters that need escaping
  *
  *	Puts string into buffer, replacing each occurrence of character from
  *	@esc with usual octal escape.  Returns 0 in case of success, -1 - in
  *	case of overflow.
  */
 int seq_escape(struct seq_file *m, const char *s, const char *esc)
 {
 	char *end = m->buf + m->size;
         char *p;
 	char c;
         for (p = m->buf + m->count; (c = *s) != '\0' && p < end; s++) {
 		if (!strchr(esc, c)) {
 			*p++ = c;
 			continue;
 		}
 		if (p + 3 < end) {
 			*p++ = '\\';
 			*p++ = '0' + ((c & 0300) >> 6);
 			*p++ = '0' + ((c & 070) >> 3);
 			*p++ = '0' + (c & 07);
 			continue;
 		}
 		m->count = m->size;
 		return -1;
         }
 	m->count = p - m->buf;
         return 0;
 }
 EXPORT_SYMBOL(seq_escape);
 int seq_printf(struct seq_file *m, const char *f, ...)
 {
 	va_list args;
 	int len;
 	if (m->count < m->size) {
 		va_start(args, f);
 		len = vsnprintf(m->buf + m->count, m->size - m->count, f, args);
 		va_end(args);
 		if (m->count + len < m->size) {
 			m->count += len;
 			return 0;
 		}
 	}
 	m->count = m->size;
 	return -1;
 }
 EXPORT_SYMBOL(seq_printf);
 /**
  *	mangle_path -	mangle and copy path to buffer beginning
  *	@s: buffer start
  *	@p: beginning of path in above buffer
  *	@esc: set of characters that need escaping
  *
  *      Copy the path from @p to @s, replacing each occurrence of character from
  *      @esc with usual octal escape.
  *      Returns pointer past last written character in @s, or NULL in case of
  *      failure.
  */
 char *mangle_path(char *s, char *p, char *esc)
 {
 	while (s <= p) {
 		char c = *p++;
 		if (!c) {
 			return s;
 		} else if (!strchr(esc, c)) {
 			*s++ = c;
 		} else if (s + 4 > p) {
 			break;
 		} else {
 			*s++ = '\\';
 			*s++ = '0' + ((c & 0300) >> 6);
 			*s++ = '0' + ((c & 070) >> 3);
 			*s++ = '0' + (c & 07);
 		}
 	}
 	return NULL;
 }
 EXPORT_SYMBOL(mangle_path);
 /**
  * seq_path - seq_file interface to print a pathname
  * @m: the seq_file handle
  * @path: the struct path to print
  * @esc: set of characters to escape in the output
  *
  * return the absolute path of 'path', as represented by the
  * dentry / mnt pair in the path parameter.
  */
 int seq_path(struct seq_file *m, struct path *path, char *esc)
 {
 	char *buf;
 	size_t size = seq_get_buf(m, &buf);
 	int res = -1;
 	if (size) {
 		char *p = d_path(path, buf, size);
 		if (!IS_ERR(p)) {
 			char *end = mangle_path(buf, p, esc);
 			if (end)
 				res = end - buf;
 		}
 	}
 	seq_commit(m, res);
 	return res;
 }
 EXPORT_SYMBOL(seq_path);
 /*
  * Same as seq_path, but relative to supplied root.
  *
  * root may be changed, see __d_path().
  */
 int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
 		  char *esc)
 {
 	char *buf;
 	size_t size = seq_get_buf(m, &buf);
 	int res = -ENAMETOOLONG;
 	if (size) {
 		char *p;
 		spin_lock(&dcache_lock);
 		p = __d_path(path, root, buf, size);
 		spin_unlock(&dcache_lock);
 		res = PTR_ERR(p);
 		if (!IS_ERR(p)) {
 			char *end = mangle_path(buf, p, esc);
 			if (end)
 				res = end - buf;
 			else
 				res = -ENAMETOOLONG;
 		}
 	}
 	seq_commit(m, res);
 	return res < 0 ? res : 0;
 }
 /*
  * returns the path of the 'dentry' from the root of its filesystem.
  */
 int seq_dentry(struct seq_file *m, struct dentry *dentry, char *esc)
 {
 	char *buf;
 	size_t size = seq_get_buf(m, &buf);
 	int res = -1;
 	if (size) {
 		char *p = dentry_path(dentry, buf, size);
 		if (!IS_ERR(p)) {
 			char *end = mangle_path(buf, p, esc);
 			if (end)
 				res = end - buf;
 		}
 	}
 	seq_commit(m, res);
 	return res;
 }
 int seq_bitmap(struct seq_file *m, const unsigned long *bits,
 				   unsigned int nr_bits)
 {
 	if (m->count < m->size) {
 		int len = bitmap_scnprintf(m->buf + m->count,
 				m->size - m->count, bits, nr_bits);
 		if (m->count + len < m->size) {
 			m->count += len;
 			return 0;
 		}
 	}
 	m->count = m->size;
 	return -1;
 }
 EXPORT_SYMBOL(seq_bitmap);
 int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
 		unsigned int nr_bits)
 {
 	if (m->count < m->size) {
 		int len = bitmap_scnlistprintf(m->buf + m->count,
 				m->size - m->count, bits, nr_bits);
 		if (m->count + len < m->size) {
 			m->count += len;
 			return 0;
 		}
 	}
 	m->count = m->size;
 	return -1;
 }
 EXPORT_SYMBOL(seq_bitmap_list);
 static void *single_start(struct seq_file *p, loff_t *pos)
 {
 	return NULL + (*pos == 0);
 }
 static void *single_next(struct seq_file *p, void *v, loff_t *pos)
 {
 	++*pos;
 	return NULL;
 }
 static void single_stop(struct seq_file *p, void *v)
 {
 }
 int single_open(struct file *file, int (*show)(struct seq_file *, void *),
 		void *data)
 {
 	struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
 	int res = -ENOMEM;
 	if (op) {
 		op->start = single_start;
 		op->next = single_next;
 		op->stop = single_stop;
 		op->show = show;
 		res = seq_open(file, op);
 		if (!res)
 			((struct seq_file *)file->private_data)->private = data;
 		else
 			kfree(op);
 	}
 	return res;
 }
 EXPORT_SYMBOL(single_open);
 int single_release(struct inode *inode, struct file *file)
 {
 	const struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
 	int res = seq_release(inode, file);
 	kfree(op);
 	return res;
 }
 EXPORT_SYMBOL(single_release);
 int seq_release_private(struct inode *inode, struct file *file)
 {
 	struct seq_file *seq = file->private_data;
 	kfree(seq->private);
 	seq->private = NULL;
 	return seq_release(inode, file);
 }
 EXPORT_SYMBOL(seq_release_private);
 void *__seq_open_private(struct file *f, const struct seq_operations *ops,
 		int psize)
 {
 	int rc;
 	void *private;
 	struct seq_file *seq;
 	private = kzalloc(psize, GFP_KERNEL);
 	if (private == NULL)
 		goto out;
 	rc = seq_open(f, ops);
 	if (rc < 0)
 		goto out_free;
 	seq = f->private_data;
 	seq->private = private;
 	return private;
 out_free:
 	kfree(private);
 out:
 	return NULL;
 }
 EXPORT_SYMBOL(__seq_open_private);
 int seq_open_private(struct file *filp, const struct seq_operations *ops,
 		int psize)
 {
 	return __seq_open_private(filp, ops, psize) ? 0 : -ENOMEM;
 }
 EXPORT_SYMBOL(seq_open_private);
 int seq_putc(struct seq_file *m, char c)
 {
 	if (m->count < m->size) {
 		m->buf[m->count++] = c;
 		return 0;
 	}
 	return -1;
 }
 EXPORT_SYMBOL(seq_putc);
 int seq_puts(struct seq_file *m, const char *s)
 {
 	int len = strlen(s);
 	if (m->count + len < m->size) {
 		memcpy(m->buf + m->count, s, len);
 		m->count += len;
 		return 0;
 	}
 	m->count = m->size;
 	return -1;
 }
 EXPORT_SYMBOL(seq_puts);
 /**
  * seq_write - write arbitrary data to buffer
  * @seq: seq_file identifying the buffer to which data should be written
  * @data: data address
  * @len: number of bytes
  *
  * Return 0 on success, non-zero otherwise.
  */
 int seq_write(struct seq_file *seq, const void *data, size_t len)
 {
 	if (seq->count + len < seq->size) {
 		memcpy(seq->buf + seq->count, data, len);
 		seq->count += len;
 		return 0;
 	}
 	seq->count = seq->size;
 	return -1;
 }
 EXPORT_SYMBOL(seq_write);
 struct list_head *seq_list_start(struct list_head *head, loff_t pos)
 {
 	struct list_head *lh;
 	list_for_each(lh, head)
 		if (pos-- == 0)
 			return lh;
 	return NULL;
 }
 EXPORT_SYMBOL(seq_list_start);
 struct list_head *seq_list_start_head(struct list_head *head, loff_t pos)
 {
 	if (!pos)
 		return head;
 	return seq_list_start(head, pos - 1);
 }
 EXPORT_SYMBOL(seq_list_start_head);
 struct list_head *seq_list_next(void *v, struct list_head *head, loff_t *ppos)
 {
 	struct list_head *lh;
 	lh = ((struct list_head *)v)->next;
 	++*ppos;
 	return lh == head ? NULL : lh;
 }
 EXPORT_SYMBOL(seq_list_next);
 /**
  * seq_hlist_start - start an iteration of a hlist
  * @head: the head of the hlist
  * @pos:  the start position of the sequence
  *
  * Called at seq_file->op->start().
  */
 struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos)
 {
 	struct hlist_node *node;
 	hlist_for_each(node, head)
 		if (pos-- == 0)
 			return node;
 	return NULL;
 }
 EXPORT_SYMBOL(seq_hlist_start);
 /**
  * seq_hlist_start_head - start an iteration of a hlist
  * @head: the head of the hlist
  * @pos:  the start position of the sequence
  *
  * Called at seq_file->op->start(). Call this function if you want to
  * print a header at the top of the output.
  */
 struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos)
 {
 	if (!pos)
 		return SEQ_START_TOKEN;
 	return seq_hlist_start(head, pos - 1);
 }
 EXPORT_SYMBOL(seq_hlist_start_head);
 /**
  * seq_hlist_next - move to the next position of the hlist
  * @v:    the current iterator
  * @head: the head of the hlist
  * @pos:  the current posision
  *
  * Called at seq_file->op->next().
  */
 struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
 				  loff_t *ppos)
 {
 	struct hlist_node *node = v;
 	++*ppos;
 	if (v == SEQ_START_TOKEN)
 		return head->first;
 	else
 		return node->next;
 }
 EXPORT_SYMBOL(seq_hlist_next);
+/**
+ * seq_hlist_start_rcu - start an iteration of a hlist protected by RCU
+ * @head: the head of the hlist
+ * @pos:  the start position of the sequence
+ *
+ * Called at seq_file->op->start().
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as hlist_add_head_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
+				       loff_t pos)
+{
+	struct hlist_node *node;
+	__hlist_for_each_rcu(node, head)
+		if (pos-- == 0)
+			return node;
+	return NULL;
+}
+EXPORT_SYMBOL(seq_hlist_start_rcu);
+/**
+ * seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU
+ * @head: the head of the hlist
+ * @pos:  the start position of the sequence
+ *
+ * Called at seq_file->op->start(). Call this function if you want to
+ * print a header at the top of the output.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as hlist_add_head_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
+					    loff_t pos)
+{
+	if (!pos)
+		return SEQ_START_TOKEN;
+	return seq_hlist_start_rcu(head, pos - 1);
+}
+EXPORT_SYMBOL(seq_hlist_start_head_rcu);
+/**
+ * seq_hlist_next_rcu - move to the next position of the hlist protected by RCU
+ * @v:    the current iterator
+ * @head: the head of the hlist
+ * @pos:  the current posision
+ *
+ * Called at seq_file->op->next().
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as hlist_add_head_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+struct hlist_node *seq_hlist_next_rcu(void *v,
+				      struct hlist_head *head,
+				      loff_t *ppos)
+{
+	struct hlist_node *node = v;
+	++*ppos;
+	if (v == SEQ_START_TOKEN)
+		return rcu_dereference(head->first);
+	else
+		return rcu_dereference(node->next);
+}
+EXPORT_SYMBOL(seq_hlist_next_rcu);

include/linux/rculist.h

Diff comments View file @ 1cc5232

 #ifndef _LINUX_RCULIST_H
 #define _LINUX_RCULIST_H
 #ifdef __KERNEL__
 /*
  * RCU-protected list version
  */
 #include <linux/list.h>
 #include <linux/rcupdate.h>
 /*
  * Insert a new entry between two known consecutive entries.
  *
  * This is only for internal list manipulation where we know
  * the prev/next entries already!
  */
 static inline void __list_add_rcu(struct list_head *new,
 		struct list_head *prev, struct list_head *next)
 {
 	new->next = next;
 	new->prev = prev;
 	rcu_assign_pointer(prev->next, new);
 	next->prev = new;
 }
 /**
  * list_add_rcu - add a new entry to rcu-protected list
  * @new: new entry to be added
  * @head: list head to add it after
  *
  * Insert a new entry after the specified head.
  * This is good for implementing stacks.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as list_add_rcu()
  * or list_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * list_for_each_entry_rcu().
  */
 static inline void list_add_rcu(struct list_head *new, struct list_head *head)
 {
 	__list_add_rcu(new, head, head->next);
 }
 /**
  * list_add_tail_rcu - add a new entry to rcu-protected list
  * @new: new entry to be added
  * @head: list head to add it before
  *
  * Insert a new entry before the specified head.
  * This is useful for implementing queues.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as list_add_tail_rcu()
  * or list_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * list_for_each_entry_rcu().
  */
 static inline void list_add_tail_rcu(struct list_head *new,
 					struct list_head *head)
 {
 	__list_add_rcu(new, head->prev, head);
 }
 /**
  * list_del_rcu - deletes entry from list without re-initialization
  * @entry: the element to delete from the list.
  *
  * Note: list_empty() on entry does not return true after this,
  * the entry is in an undefined state. It is useful for RCU based
  * lockfree traversal.
  *
  * In particular, it means that we can not poison the forward
  * pointers that may still be used for walking the list.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as list_del_rcu()
  * or list_add_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * list_for_each_entry_rcu().
  *
  * Note that the caller is not permitted to immediately free
  * the newly deleted entry.  Instead, either synchronize_rcu()
  * or call_rcu() must be used to defer freeing until an RCU
  * grace period has elapsed.
  */
 static inline void list_del_rcu(struct list_head *entry)
 {
 	__list_del(entry->prev, entry->next);
 	entry->prev = LIST_POISON2;
 }
 /**
  * hlist_del_init_rcu - deletes entry from hash list with re-initialization
  * @n: the element to delete from the hash list.
  *
  * Note: list_unhashed() on the node return true after this. It is
  * useful for RCU based read lockfree traversal if the writer side
  * must know if the list entry is still hashed or already unhashed.
  *
  * In particular, it means that we can not poison the forward pointers
  * that may still be used for walking the hash list and we can only
  * zero the pprev pointer so list_unhashed() will return true after
  * this.
  *
  * The caller must take whatever precautions are necessary (such as
  * holding appropriate locks) to avoid racing with another
  * list-mutation primitive, such as hlist_add_head_rcu() or
  * hlist_del_rcu(), running on this same list.  However, it is
  * perfectly legal to run concurrently with the _rcu list-traversal
  * primitives, such as hlist_for_each_entry_rcu().
  */
 static inline void hlist_del_init_rcu(struct hlist_node *n)
 {
 	if (!hlist_unhashed(n)) {
 		__hlist_del(n);
 		n->pprev = NULL;
 	}
 }
 /**
  * list_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
  *
  * The @old entry will be replaced with the @new entry atomically.
  * Note: @old should not be empty.
  */
 static inline void list_replace_rcu(struct list_head *old,
 				struct list_head *new)
 {
 	new->next = old->next;
 	new->prev = old->prev;
 	rcu_assign_pointer(new->prev->next, new);
 	new->next->prev = new;
 	old->prev = LIST_POISON2;
 }
 /**
  * list_splice_init_rcu - splice an RCU-protected list into an existing list.
  * @list:	the RCU-protected list to splice
  * @head:	the place in the list to splice the first list into
  * @sync:	function to sync: synchronize_rcu(), synchronize_sched(), ...
  *
  * @head can be RCU-read traversed concurrently with this function.
  *
  * Note that this function blocks.
  *
  * Important note: the caller must take whatever action is necessary to
  *	prevent any other updates to @head.  In principle, it is possible
  *	to modify the list as soon as sync() begins execution.
  *	If this sort of thing becomes necessary, an alternative version
  *	based on call_rcu() could be created.  But only if -really-
  *	needed -- there is no shortage of RCU API members.
  */
 static inline void list_splice_init_rcu(struct list_head *list,
 					struct list_head *head,
 					void (*sync)(void))
 {
 	struct list_head *first = list->next;
 	struct list_head *last = list->prev;
 	struct list_head *at = head->next;
 	if (list_empty(head))
 		return;
 	/* "first" and "last" tracking list, so initialize it. */
 	INIT_LIST_HEAD(list);
 	/*
 	 * At this point, the list body still points to the source list.
 	 * Wait for any readers to finish using the list before splicing
 	 * the list body into the new list.  Any new readers will see
 	 * an empty list.
 	 */
 	sync();
 	/*
 	 * Readers are finished with the source list, so perform splice.
 	 * The order is important if the new list is global and accessible
 	 * to concurrent RCU readers.  Note that RCU readers are not
 	 * permitted to traverse the prev pointers without excluding
 	 * this function.
 	 */
 	last->next = at;
 	rcu_assign_pointer(head->next, first);
 	first->prev = head;
 	at->prev = last;
 }
 /**
  * list_entry_rcu - get the struct for this entry
  * @ptr:        the &struct list_head pointer.
  * @type:       the type of the struct this is embedded in.
  * @member:     the name of the list_struct within the struct.
  *
  * This primitive may safely run concurrently with the _rcu list-mutation
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
  */
 #define list_entry_rcu(ptr, type, member) \
 	container_of(rcu_dereference(ptr), type, member)
 /**
  * list_first_entry_rcu - get the first element from a list
  * @ptr:        the list head to take the element from.
  * @type:       the type of the struct this is embedded in.
  * @member:     the name of the list_struct within the struct.
  *
  * Note, that list is expected to be not empty.
  *
  * This primitive may safely run concurrently with the _rcu list-mutation
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
  */
 #define list_first_entry_rcu(ptr, type, member) \
 	list_entry_rcu((ptr)->next, type, member)
 #define __list_for_each_rcu(pos, head) \
 	for (pos = rcu_dereference((head)->next); \
 		pos != (head); \
 		pos = rcu_dereference(pos->next))
 /**
  * list_for_each_entry_rcu	-	iterate over rcu list of given type
  * @pos:	the type * to use as a loop cursor.
  * @head:	the head for your list.
  * @member:	the name of the list_struct within the struct.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_entry_rcu(pos, head, member) \
 	for (pos = list_entry_rcu((head)->next, typeof(*pos), member); \
 		prefetch(pos->member.next), &pos->member != (head); \
 		pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 /**
  * list_for_each_continue_rcu
  * @pos:	the &struct list_head to use as a loop cursor.
  * @head:	the head for your list.
  *
  * Iterate over an rcu-protected list, continuing after current point.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_continue_rcu(pos, head) \
 	for ((pos) = rcu_dereference((pos)->next); \
 		prefetch((pos)->next), (pos) != (head); \
 		(pos) = rcu_dereference((pos)->next))
 /**
  * list_for_each_entry_continue_rcu - continue iteration over list of given type
  * @pos:	the type * to use as a loop cursor.
  * @head:	the head for your list.
  * @member:	the name of the list_struct within the struct.
  *
  * Continue to iterate over list of given type, continuing after
  * the current position.
  */
 #define list_for_each_entry_continue_rcu(pos, head, member) 		\
 	for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \
 	     prefetch(pos->member.next), &pos->member != (head);	\
 	     pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 /**
  * hlist_del_rcu - deletes entry from hash list without re-initialization
  * @n: the element to delete from the hash list.
  *
  * Note: list_unhashed() on entry does not return true after this,
  * the entry is in an undefined state. It is useful for RCU based
  * lockfree traversal.
  *
  * In particular, it means that we can not poison the forward
  * pointers that may still be used for walking the hash list.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry().
  */
 static inline void hlist_del_rcu(struct hlist_node *n)
 {
 	__hlist_del(n);
 	n->pprev = LIST_POISON2;
 }
 /**
  * hlist_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
  *
  * The @old entry will be replaced with the @new entry atomically.
  */
 static inline void hlist_replace_rcu(struct hlist_node *old,
 					struct hlist_node *new)
 {
 	struct hlist_node *next = old->next;
 	new->next = next;
 	new->pprev = old->pprev;
 	rcu_assign_pointer(*new->pprev, new);
 	if (next)
 		new->next->pprev = &new->next;
 	old->pprev = LIST_POISON2;
 }
 /**
  * hlist_add_head_rcu
  * @n: the element to add to the hash list.
  * @h: the list to add to.
  *
  * Description:
  * Adds the specified element to the specified hlist,
  * while permitting racing traversals.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.  Regardless of the type of CPU, the
  * list-traversal primitive must be guarded by rcu_read_lock().
  */
 static inline void hlist_add_head_rcu(struct hlist_node *n,
 					struct hlist_head *h)
 {
 	struct hlist_node *first = h->first;
 	n->next = first;
 	n->pprev = &h->first;
 	rcu_assign_pointer(h->first, n);
 	if (first)
 		first->pprev = &n->next;
 }
 /**
  * hlist_add_before_rcu
  * @n: the new element to add to the hash list.
  * @next: the existing element to add the new element before.
  *
  * Description:
  * Adds the specified element to the specified hlist
  * before the specified node while permitting racing traversals.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
 static inline void hlist_add_before_rcu(struct hlist_node *n,
 					struct hlist_node *next)
 {
 	n->pprev = next->pprev;
 	n->next = next;
 	rcu_assign_pointer(*(n->pprev), n);
 	next->pprev = &n->next;
 }
 /**
  * hlist_add_after_rcu
  * @prev: the existing element to add the new element after.
  * @n: the new element to add to the hash list.
  *
  * Description:
  * Adds the specified element to the specified hlist
  * after the specified node while permitting racing traversals.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
 static inline void hlist_add_after_rcu(struct hlist_node *prev,
 				       struct hlist_node *n)
 {
 	n->next = prev->next;
 	n->pprev = &prev->next;
 	rcu_assign_pointer(prev->next, n);
 	if (n->next)
 		n->next->pprev = &n->next;
 }
+#define __hlist_for_each_rcu(pos, head)			\
+	for (pos = rcu_dereference((head)->first);	\
+	     pos && ({ prefetch(pos->next); 1; });	\
+	     pos = rcu_dereference(pos->next))
 /**
  * hlist_for_each_entry_rcu - iterate over rcu list of given type
  * @tpos:	the type * to use as a loop cursor.
  * @pos:	the &struct hlist_node to use as a loop cursor.
  * @head:	the head for your list.
  * @member:	the name of the hlist_node within the struct.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define hlist_for_each_entry_rcu(tpos, pos, head, member)		 \
 	for (pos = rcu_dereference((head)->first);			 \
 		pos && ({ prefetch(pos->next); 1; }) &&			 \
 		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
 		pos = rcu_dereference(pos->next))
 #endif	/* __KERNEL__ */
 #endif

include/linux/seq_file.h

Diff comments View file @ 1cc5232

 #ifndef _LINUX_SEQ_FILE_H
 #define _LINUX_SEQ_FILE_H
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/mutex.h>
 #include <linux/cpumask.h>
 #include <linux/nodemask.h>
 struct seq_operations;
 struct file;
 struct path;
 struct inode;
 struct dentry;
 struct seq_file {
 	char *buf;
 	size_t size;
 	size_t from;
 	size_t count;
 	loff_t index;
 	loff_t read_pos;
 	u64 version;
 	struct mutex lock;
 	const struct seq_operations *op;
 	void *private;
 };
 struct seq_operations {
 	void * (*start) (struct seq_file *m, loff_t *pos);
 	void (*stop) (struct seq_file *m, void *v);
 	void * (*next) (struct seq_file *m, void *v, loff_t *pos);
 	int (*show) (struct seq_file *m, void *v);
 };
 #define SEQ_SKIP 1
 /**
  * seq_get_buf - get buffer to write arbitrary data to
  * @m: the seq_file handle
  * @bufp: the beginning of the buffer is stored here
  *
  * Return the number of bytes available in the buffer, or zero if
  * there's no space.
  */
 static inline size_t seq_get_buf(struct seq_file *m, char **bufp)
 {
 	BUG_ON(m->count > m->size);
 	if (m->count < m->size)
 		*bufp = m->buf + m->count;
 	else
 		*bufp = NULL;
 	return m->size - m->count;
 }
 /**
  * seq_commit - commit data to the buffer
  * @m: the seq_file handle
  * @num: the number of bytes to commit
  *
  * Commit @num bytes of data written to a buffer previously acquired
  * by seq_buf_get.  To signal an error condition, or that the data
  * didn't fit in the available space, pass a negative @num value.
  */
 static inline void seq_commit(struct seq_file *m, int num)
 {
 	if (num < 0) {
 		m->count = m->size;
 	} else {
 		BUG_ON(m->count + num > m->size);
 		m->count += num;
 	}
 }
 char *mangle_path(char *s, char *p, char *esc);
 int seq_open(struct file *, const struct seq_operations *);
 ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);
 loff_t seq_lseek(struct file *, loff_t, int);
 int seq_release(struct inode *, struct file *);
 int seq_escape(struct seq_file *, const char *, const char *);
 int seq_putc(struct seq_file *m, char c);
 int seq_puts(struct seq_file *m, const char *s);
 int seq_write(struct seq_file *seq, const void *data, size_t len);
 int seq_printf(struct seq_file *, const char *, ...)
 	__attribute__ ((format (printf,2,3)));
 int seq_path(struct seq_file *, struct path *, char *);
 int seq_dentry(struct seq_file *, struct dentry *, char *);
 int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
 		  char *esc);
 int seq_bitmap(struct seq_file *m, const unsigned long *bits,
 				   unsigned int nr_bits);
 static inline int seq_cpumask(struct seq_file *m, const struct cpumask *mask)
 {
 	return seq_bitmap(m, cpumask_bits(mask), nr_cpu_ids);
 }
 static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
 {
 	return seq_bitmap(m, mask->bits, MAX_NUMNODES);
 }
 int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
 		unsigned int nr_bits);
 static inline int seq_cpumask_list(struct seq_file *m,
 				   const struct cpumask *mask)
 {
 	return seq_bitmap_list(m, cpumask_bits(mask), nr_cpu_ids);
 }
 static inline int seq_nodemask_list(struct seq_file *m, nodemask_t *mask)
 {
 	return seq_bitmap_list(m, mask->bits, MAX_NUMNODES);
 }
 int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
 int single_release(struct inode *, struct file *);
 void *__seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_release_private(struct inode *, struct file *);
 #define SEQ_START_TOKEN ((void *)1)
 /*
  * Helpers for iteration over list_head-s in seq_files
  */
 extern struct list_head *seq_list_start(struct list_head *head,
 		loff_t pos);
 extern struct list_head *seq_list_start_head(struct list_head *head,
 		loff_t pos);
 extern struct list_head *seq_list_next(void *v, struct list_head *head,
 		loff_t *ppos);
 /*
  * Helpers for iteration over hlist_head-s in seq_files
  */
 extern struct hlist_node *seq_hlist_start(struct hlist_head *head,
-		loff_t pos);
+					  loff_t pos);
 extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head,
-		loff_t pos);
+					       loff_t pos);
 extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
-		loff_t *ppos);
+					 loff_t *ppos);
+extern struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
+					      loff_t pos);
+extern struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
+						   loff_t pos);
+extern struct hlist_node *seq_hlist_next_rcu(void *v,
+						   struct hlist_head *head,
+						   loff_t *ppos);
 #endif