From 62a268bd01cb37fd7c08f68f81b704ccccb05717 Mon Sep 17 00:00:00 2001 From: Jens Axboe Date: Mon, 27 Feb 2006 12:01:47 +0100 Subject: [PATCH] [PATCH] kernel: -rc5 update --- ...rc4-git-E0 => blk-trace-2.6.16-rc5-git-A0} | 387 ++++++++++++------ 1 file changed, 271 insertions(+), 116 deletions(-) rename kernel/{blk-trace-2.6.16-rc4-git-E0 => blk-trace-2.6.16-rc5-git-A0} (92%) diff --git a/kernel/blk-trace-2.6.16-rc4-git-E0 b/kernel/blk-trace-2.6.16-rc5-git-A0 similarity index 92% rename from kernel/blk-trace-2.6.16-rc4-git-E0 rename to kernel/blk-trace-2.6.16-rc5-git-A0 index e473fcc..c7e5ee0 100644 --- a/kernel/blk-trace-2.6.16-rc4-git-E0 +++ b/kernel/blk-trace-2.6.16-rc5-git-A0 @@ -796,7 +796,7 @@ index 0d65394..234048e 100644 } diff --git a/drivers/md/dm.c b/drivers/md/dm.c -index e9adeb9..c8f3aa2 100644 +index 745ca1f..f36613e 100644 --- a/drivers/md/dm.c +++ b/drivers/md/dm.c @@ -17,6 +17,7 @@ @@ -901,7 +901,7 @@ index 1f3bb50..0dd0d81 100644 BUG_ON(bi->bi_idx != 0); atomic_set(&bp->cnt, 3); diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c -index 057e602..893d600 100644 +index 537ac70..48318d9 100644 --- a/fs/compat_ioctl.c +++ b/fs/compat_ioctl.c @@ -72,6 +72,7 @@ @@ -2725,139 +2725,294 @@ index e059da9..c7a63cd 100644 #define BMAP_IOCTL 1 /* obsolete - kept for compatibility */ #define FIBMAP _IO(0x00,1) /* bmap access */ -diff --git a/include/linux/relayfs_fs.h b/include/linux/relay.h -similarity index 89% -rename from include/linux/relayfs_fs.h -rename to include/linux/relay.h -index 7342e66..0b456ec 100644 ---- a/include/linux/relayfs_fs.h +diff --git a/include/linux/relay.h b/include/linux/relay.h +new file mode 100644 +index 0000000..0b456ec +--- /dev/null +++ b/include/linux/relay.h -@@ -1,14 +1,14 @@ - /* -- * linux/include/linux/relayfs_fs.h +@@ -0,0 +1,282 @@ ++/* + * linux/include/linux/relay.h - * - * Copyright (C) 2002, 2003 - Tom Zanussi (zanussi@us.ibm.com), IBM Corp - * Copyright (C) 1999, 2000, 2001, 2002 - Karim Yaghmour (karim@opersys.com) - * -- * RelayFS definitions and declarations ++ * ++ * Copyright (C) 2002, 2003 - Tom Zanussi (zanussi@us.ibm.com), IBM Corp ++ * Copyright (C) 1999, 2000, 2001, 2002 - Karim Yaghmour (karim@opersys.com) ++ * + * CONFIG_RELAY definitions and declarations - */ - --#ifndef _LINUX_RELAYFS_FS_H --#define _LINUX_RELAYFS_FS_H ++ */ ++ +#ifndef _LINUX_RELAY_H +#define _LINUX_RELAY_H - - #include - #include -@@ -19,6 +19,9 @@ - #include - #include - ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ +/* Needs a _much_ better name... */ +#define FIX_SIZE(x) ((((x) - 1) & PAGE_MASK) + PAGE_SIZE) + - /* - * Tracks changes to rchan/rchan_buf structs - */ -@@ -46,6 +49,7 @@ struct rchan_buf - size_t prev_padding; /* temporary variable */ - size_t bytes_consumed; /* bytes consumed in cur read subbuf */ - unsigned int cpu; /* this buf's cpu */ ++/* ++ * Tracks changes to rchan/rchan_buf structs ++ */ ++#define RELAYFS_CHANNEL_VERSION 6 ++ ++/* ++ * Per-cpu relay channel buffer ++ */ ++struct rchan_buf ++{ ++ void *start; /* start of channel buffer */ ++ void *data; /* start of current sub-buffer */ ++ size_t offset; /* current offset into sub-buffer */ ++ size_t subbufs_produced; /* count of sub-buffers produced */ ++ size_t subbufs_consumed; /* count of sub-buffers consumed */ ++ struct rchan *chan; /* associated channel */ ++ wait_queue_head_t read_wait; /* reader wait queue */ ++ struct work_struct wake_readers; /* reader wake-up work struct */ ++ struct dentry *dentry; /* channel file dentry */ ++ struct kref kref; /* channel buffer refcount */ ++ struct page **page_array; /* array of current buffer pages */ ++ unsigned int page_count; /* number of current buffer pages */ ++ unsigned int finalized; /* buffer has been finalized */ ++ size_t *padding; /* padding counts per sub-buffer */ ++ size_t prev_padding; /* temporary variable */ ++ size_t bytes_consumed; /* bytes consumed in cur read subbuf */ ++ unsigned int cpu; /* this buf's cpu */ + unsigned int poll_flags; - } ____cacheline_aligned; - - /* -@@ -92,26 +96,26 @@ struct rchan_callbacks - size_t prev_padding); - - /* -- * buf_mapped - relayfs buffer mmap notification ++} ____cacheline_aligned; ++ ++/* ++ * Relay channel data structure ++ */ ++struct rchan ++{ ++ u32 version; /* the version of this struct */ ++ size_t subbuf_size; /* sub-buffer size */ ++ size_t n_subbufs; /* number of sub-buffers per buffer */ ++ size_t alloc_size; /* total buffer size allocated */ ++ struct rchan_callbacks *cb; /* client callbacks */ ++ struct kref kref; /* channel refcount */ ++ void *private_data; /* for user-defined data */ ++ size_t last_toobig; /* tried to log event > subbuf size */ ++ struct rchan_buf *buf[NR_CPUS]; /* per-cpu channel buffers */ ++}; ++ ++/* ++ * Relay channel client callbacks ++ */ ++struct rchan_callbacks ++{ ++ /* ++ * subbuf_start - called on buffer-switch to a new sub-buffer ++ * @buf: the channel buffer containing the new sub-buffer ++ * @subbuf: the start of the new sub-buffer ++ * @prev_subbuf: the start of the previous sub-buffer ++ * @prev_padding: unused space at the end of previous sub-buffer ++ * ++ * The client should return 1 to continue logging, 0 to stop ++ * logging. ++ * ++ * NOTE: subbuf_start will also be invoked when the buffer is ++ * created, so that the first sub-buffer can be initialized ++ * if necessary. In this case, prev_subbuf will be NULL. ++ * ++ * NOTE: the client can reserve bytes at the beginning of the new ++ * sub-buffer by calling subbuf_start_reserve() in this callback. ++ */ ++ int (*subbuf_start) (struct rchan_buf *buf, ++ void *subbuf, ++ void *prev_subbuf, ++ size_t prev_padding); ++ ++ /* + * buf_mapped - relay buffer mmap notification - * @buf: the channel buffer -- * @filp: relayfs file pointer ++ * @buf: the channel buffer + * @filp: relay file pointer - * -- * Called when a relayfs file is successfully mmapped ++ * + * Called when a relay file is successfully mmapped - */ - void (*buf_mapped)(struct rchan_buf *buf, - struct file *filp); - - /* -- * buf_unmapped - relayfs buffer unmap notification ++ */ ++ void (*buf_mapped)(struct rchan_buf *buf, ++ struct file *filp); ++ ++ /* + * buf_unmapped - relay buffer unmap notification - * @buf: the channel buffer -- * @filp: relayfs file pointer ++ * @buf: the channel buffer + * @filp: relay file pointer - * -- * Called when a relayfs file is successfully unmapped ++ * + * Called when a relay file is successfully unmapped - */ - void (*buf_unmapped)(struct rchan_buf *buf, - struct file *filp); - /* -- * create_buf_file - create file to represent a relayfs channel buffer ++ */ ++ void (*buf_unmapped)(struct rchan_buf *buf, ++ struct file *filp); ++ /* + * create_buf_file - create file to represent a relay channel buffer - * @filename: the name of the file to create - * @parent: the parent of the file to create - * @mode: the mode of the file to create -@@ -121,7 +125,7 @@ struct rchan_callbacks - * Called during relay_open(), once for each per-cpu buffer, - * to allow the client to create a file to be used to - * represent the corresponding channel buffer. If the file is -- * created outside of relayfs, the parent must also exist in ++ * @filename: the name of the file to create ++ * @parent: the parent of the file to create ++ * @mode: the mode of the file to create ++ * @buf: the channel buffer ++ * @is_global: outparam - set non-zero if the buffer should be global ++ * ++ * Called during relay_open(), once for each per-cpu buffer, ++ * to allow the client to create a file to be used to ++ * represent the corresponding channel buffer. If the file is + * created outside of relay, the parent must also exist in - * that filesystem. - * - * The callback should return the dentry of the file created -@@ -140,7 +144,7 @@ struct rchan_callbacks - int *is_global); - - /* -- * remove_buf_file - remove file representing a relayfs channel buffer ++ * that filesystem. ++ * ++ * The callback should return the dentry of the file created ++ * to represent the relay buffer. ++ * ++ * Setting the is_global outparam to a non-zero value will ++ * cause relay_open() to create a single global buffer rather ++ * than the default set of per-cpu buffers. ++ * ++ * See Documentation/filesystems/relayfs.txt for more info. ++ */ ++ struct dentry *(*create_buf_file)(const char *filename, ++ struct dentry *parent, ++ int mode, ++ struct rchan_buf *buf, ++ int *is_global); ++ ++ /* + * remove_buf_file - remove file representing a relay channel buffer - * @dentry: the dentry of the file to remove - * - * Called during relay_close(), once for each per-cpu buffer, -@@ -153,7 +157,7 @@ struct rchan_callbacks - }; - - /* -- * relayfs kernel API, fs/relayfs/relay.c ++ * @dentry: the dentry of the file to remove ++ * ++ * Called during relay_close(), once for each per-cpu buffer, ++ * to allow the client to remove a file used to represent a ++ * channel buffer. ++ * ++ * The callback should return 0 if successful, negative if not. ++ */ ++ int (*remove_buf_file)(struct dentry *dentry); ++}; ++ ++/* + * CONFIG_RELAY kernel API, kernel/relay.c - */ - - struct rchan *relay_open(const char *base_filename, -@@ -171,15 +175,6 @@ extern int relay_buf_full(struct rchan_b - - extern size_t relay_switch_subbuf(struct rchan_buf *buf, - size_t length); --extern struct dentry *relayfs_create_dir(const char *name, -- struct dentry *parent); --extern int relayfs_remove_dir(struct dentry *dentry); --extern struct dentry *relayfs_create_file(const char *name, -- struct dentry *parent, -- int mode, -- struct file_operations *fops, -- void *data); --extern int relayfs_remove_file(struct dentry *dentry); - - /** - * relay_write - write data into the channel -@@ -279,9 +274,9 @@ static inline void subbuf_start_reserve( - } - - /* -- * exported relay file operations, fs/relayfs/inode.c ++ */ ++ ++struct rchan *relay_open(const char *base_filename, ++ struct dentry *parent, ++ size_t subbuf_size, ++ size_t n_subbufs, ++ struct rchan_callbacks *cb); ++extern void relay_close(struct rchan *chan); ++extern void relay_flush(struct rchan *chan); ++extern void relay_subbufs_consumed(struct rchan *chan, ++ unsigned int cpu, ++ size_t consumed); ++extern void relay_reset(struct rchan *chan); ++extern int relay_buf_full(struct rchan_buf *buf); ++ ++extern size_t relay_switch_subbuf(struct rchan_buf *buf, ++ size_t length); ++ ++/** ++ * relay_write - write data into the channel ++ * @chan: relay channel ++ * @data: data to be written ++ * @length: number of bytes to write ++ * ++ * Writes data into the current cpu's channel buffer. ++ * ++ * Protects the buffer by disabling interrupts. Use this ++ * if you might be logging from interrupt context. Try ++ * __relay_write() if you know you won't be logging from ++ * interrupt context. ++ */ ++static inline void relay_write(struct rchan *chan, ++ const void *data, ++ size_t length) ++{ ++ unsigned long flags; ++ struct rchan_buf *buf; ++ ++ local_irq_save(flags); ++ buf = chan->buf[smp_processor_id()]; ++ if (unlikely(buf->offset + length > chan->subbuf_size)) ++ length = relay_switch_subbuf(buf, length); ++ memcpy(buf->data + buf->offset, data, length); ++ buf->offset += length; ++ local_irq_restore(flags); ++} ++ ++/** ++ * __relay_write - write data into the channel ++ * @chan: relay channel ++ * @data: data to be written ++ * @length: number of bytes to write ++ * ++ * Writes data into the current cpu's channel buffer. ++ * ++ * Protects the buffer by disabling preemption. Use ++ * relay_write() if you might be logging from interrupt ++ * context. ++ */ ++static inline void __relay_write(struct rchan *chan, ++ const void *data, ++ size_t length) ++{ ++ struct rchan_buf *buf; ++ ++ buf = chan->buf[get_cpu()]; ++ if (unlikely(buf->offset + length > buf->chan->subbuf_size)) ++ length = relay_switch_subbuf(buf, length); ++ memcpy(buf->data + buf->offset, data, length); ++ buf->offset += length; ++ put_cpu(); ++} ++ ++/** ++ * relay_reserve - reserve slot in channel buffer ++ * @chan: relay channel ++ * @length: number of bytes to reserve ++ * ++ * Returns pointer to reserved slot, NULL if full. ++ * ++ * Reserves a slot in the current cpu's channel buffer. ++ * Does not protect the buffer at all - caller must provide ++ * appropriate synchronization. ++ */ ++static inline void *relay_reserve(struct rchan *chan, size_t length) ++{ ++ void *reserved; ++ struct rchan_buf *buf = chan->buf[smp_processor_id()]; ++ ++ if (unlikely(buf->offset + length > buf->chan->subbuf_size)) { ++ length = relay_switch_subbuf(buf, length); ++ if (!length) ++ return NULL; ++ } ++ reserved = buf->data + buf->offset; ++ buf->offset += length; ++ ++ return reserved; ++} ++ ++/** ++ * subbuf_start_reserve - reserve bytes at the start of a sub-buffer ++ * @buf: relay channel buffer ++ * @length: number of bytes to reserve ++ * ++ * Helper function used to reserve bytes at the beginning of ++ * a sub-buffer in the subbuf_start() callback. ++ */ ++static inline void subbuf_start_reserve(struct rchan_buf *buf, ++ size_t length) ++{ ++ BUG_ON(length >= buf->chan->subbuf_size - 1); ++ buf->offset = length; ++} ++ ++/* + * exported relay file operations, kernel/relay.c - */ - extern struct file_operations relay_file_operations; - --#endif /* _LINUX_RELAYFS_FS_H */ ++ */ ++extern struct file_operations relay_file_operations; ++ +#endif /* _LINUX_RELAY_H */ - ++ diff --git a/include/linux/sched.h b/include/linux/sched.h index b6f51e3..d9d465b 100644 --- a/include/linux/sched.h @@ -2980,7 +3135,7 @@ index fbea12d..f564e9b 100644 diff --git a/kernel/relay.c b/kernel/relay.c new file mode 100644 -index 0000000..7fbdf78 +index 0000000..50edac5 --- /dev/null +++ b/kernel/relay.c @@ -0,0 +1,1006 @@ @@ -3257,7 +3412,7 @@ index 0000000..7fbdf78 +} + +/* -+ * create_buf_file_create() default callback. Does nothing. ++ * create_buf_file_create() default callback. Does nothing. + */ +static struct dentry *create_buf_file_default_callback(const char *filename, + struct dentry *parent, -- 2.25.1