Commit c2e95c3f authored by Linus Torvalds's avatar Linus Torvalds

Merge master.kernel.org:/home/hch/BK/xfs/linux-2.5

into home.transmeta.com:/home/torvalds/v2.5/linux
parents 028d2f3e b33cc8f7
......@@ -1453,6 +1453,7 @@ static inline void discard_buffer(struct buffer_head * bh)
clear_buffer_mapped(bh);
clear_buffer_req(bh);
clear_buffer_new(bh);
clear_buffer_delay(bh);
unlock_buffer(bh);
}
......@@ -1871,7 +1872,7 @@ static int __block_prepare_write(struct inode *inode, struct page *page,
set_buffer_uptodate(bh);
continue;
}
if (!buffer_uptodate(bh) &&
if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
(block_start < from || block_end > to)) {
ll_rw_block(READ, 1, &bh);
*wait_bh++=bh;
......@@ -2457,7 +2458,7 @@ int block_truncate_page(struct address_space *mapping,
if (PageUptodate(page))
set_buffer_uptodate(bh);
if (!buffer_uptodate(bh)) {
if (!buffer_uptodate(bh) && !buffer_delay(bh)) {
err = -EIO;
ll_rw_block(READ, 1, &bh);
wait_on_buffer(bh);
......
......@@ -51,23 +51,22 @@ export-objs := pagebuf/page_buf.o support/ktrace.o \
obj-$(CONFIG_XFS_FS) += xfs.o
xfs-obj-$(CONFIG_XFS_RT) += xfs_rtalloc.o
xfs-$(CONFIG_XFS_RT) += xfs_rtalloc.o
xfs-obj-$(CONFIG_XFS_QUOTA) += xfs_dquot.o \
xfs-$(CONFIG_XFS_QUOTA) += xfs_dquot.o \
xfs_dquot_item.o \
xfs_trans_dquot.o \
xfs_qm_syscalls.o \
xfs_qm.o
xfs-obj-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.o
xfs-obj-$(CONFIG_FS_POSIX_CAP) += xfs_cap.o
xfs-obj-$(CONFIG_FS_POSIX_MAC) += xfs_mac.o
xfs-obj-$(CONFIG_PROC_FS) += linux/xfs_stats.o
xfs-obj-$(CONFIG_SYSCTL) += linux/xfs_sysctl.o
xfs-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.o
xfs-$(CONFIG_FS_POSIX_CAP) += xfs_cap.o
xfs-$(CONFIG_FS_POSIX_MAC) += xfs_mac.o
xfs-$(CONFIG_PROC_FS) += linux/xfs_stats.o
xfs-$(CONFIG_SYSCTL) += linux/xfs_sysctl.o
xfs-objs += $(xfs-obj-y) \
xfs_alloc.o \
xfs-y += xfs_alloc.o \
xfs_alloc_btree.o \
xfs_attr.o \
xfs_attr_fetch.o \
......@@ -115,12 +114,12 @@ xfs-objs += $(xfs-obj-y) \
xfs_rw.o
# Objects in pagebuf/
xfs-objs += $(addprefix pagebuf/, \
xfs-y += $(addprefix pagebuf/, \
page_buf.o \
page_buf_locking.o)
# Objects in linux/
xfs-objs += $(addprefix linux/, \
xfs-y += $(addprefix linux/, \
xfs_aops.o \
xfs_behavior.o \
xfs_file.o \
......@@ -134,7 +133,7 @@ xfs-objs += $(addprefix linux/, \
xfs_vnode.o)
# Objects in support/
xfs-objs += $(addprefix support/, \
xfs-y += $(addprefix support/, \
debug.o \
kmem.o \
ktrace.o \
......
......@@ -48,6 +48,9 @@ map_blocks(
vnode_t *vp = LINVFS_GET_VP(inode);
int error, nmaps = 1;
if (((flags & (PBF_DIRECT|PBF_SYNC)) == PBF_DIRECT) &&
(offset >= inode->i_size))
count = max(count, XFS_WRITE_IO_LOG);
retry:
VOP_BMAP(vp, offset, count, flags, pbmapp, &nmaps, error);
if (flags & PBF_WRITE) {
......@@ -145,9 +148,8 @@ probe_unmapped_page(
struct buffer_head *bh, *head;
bh = head = page_buffers(page);
do {
if (buffer_mapped(bh) || !buffer_uptodate(bh)) {
if (buffer_mapped(bh) || !buffer_uptodate(bh))
break;
}
ret += bh->b_size;
if (ret >= pg_offset)
break;
......@@ -289,7 +291,7 @@ convert_page(
bh = head = page_buffers(page);
do {
offset = i << bbits;
if (!buffer_uptodate(bh))
if (!(PageUptodate(page) || buffer_uptodate(bh)))
continue;
if (buffer_mapped(bh) && !buffer_delay(bh) && all_bh) {
if (startio && (offset < end)) {
......@@ -372,7 +374,7 @@ delalloc_convert(
page_buf_bmap_t *mp, map;
unsigned long p_offset = 0, end_index;
loff_t offset, end_offset;
int len, err, i, cnt = 0;
int len, err, i, cnt = 0, uptodate = 1;
/* Are we off the end of the file ? */
end_index = inode->i_size >> PAGE_CACHE_SHIFT;
......@@ -396,7 +398,7 @@ delalloc_convert(
len = bh->b_size;
do {
if (!buffer_uptodate(bh) && !startio) {
if (!(PageUptodate(page) || buffer_uptodate(bh)) && !startio) {
goto next_bh;
}
......@@ -423,48 +425,57 @@ delalloc_convert(
unlock_buffer(bh);
}
}
} else if (!buffer_mapped(bh) &&
(buffer_uptodate(bh) || PageUptodate(page))
&& (allocate_space || startio)) {
int size;
/* Getting here implies an unmapped buffer was found,
* and we are in a path where we need to write the
* whole page out.
*/
if (!mp) {
size = probe_unmapped_cluster(inode, page,
bh, head);
err = map_blocks(inode, offset, size, &map,
PBF_WRITE|PBF_DIRECT);
if (err) {
goto error;
} else if ((buffer_uptodate(bh) || PageUptodate(page)) &&
(allocate_space || startio)) {
if (!buffer_mapped(bh)) {
int size;
/*
* Getting here implies an unmapped buffer
* was found, and we are in a path where we
* need to write the whole page out.
*/
if (!mp) {
size = probe_unmapped_cluster(
inode, page, bh, head);
err = map_blocks(inode, offset,
size, &map,
PBF_WRITE | PBF_DIRECT);
if (err) {
goto error;
}
mp = match_offset_to_mapping(page, &map,
p_offset);
}
mp = match_offset_to_mapping(page, &map,
p_offset);
}
if (mp) {
map_buffer_at_offset(page, bh, p_offset,
inode->i_blkbits, mp);
if (startio) {
if (mp) {
map_buffer_at_offset(page,
bh, p_offset,
inode->i_blkbits, mp);
if (startio) {
bh_arr[cnt++] = bh;
} else {
unlock_buffer(bh);
}
}
} else if (startio && buffer_mapped(bh)) {
if (buffer_uptodate(bh) && allocate_space) {
lock_buffer(bh);
bh_arr[cnt++] = bh;
} else {
unlock_buffer(bh);
}
}
} else if (startio && buffer_mapped(bh)) {
if(buffer_uptodate(bh) && allocate_space) {
lock_buffer(bh);
bh_arr[cnt++] = bh;
}
}
next_bh:
if (!buffer_uptodate(bh))
uptodate = 0;
offset += len;
p_offset += len;
bh = bh->b_this_page;
} while (offset < end_offset);
if (uptodate)
SetPageUptodate(page);
if (startio) {
submit_page(page, bh_arr, cnt);
}
......@@ -509,17 +520,15 @@ linvfs_get_block_core(
ssize_t size;
loff_t offset = (loff_t)iblock << inode->i_blkbits;
if (blocks) {
/* If we are doing writes at the end of the file,
* allocate in chunks
*/
if (blocks)
size = blocks << inode->i_blkbits;
} else {
/* If we are doing writes at the end of the file,
* allocate in chunks
*/
if (create && (offset >= inode->i_size) && !(flags & PBF_SYNC))
size = 1 << XFS_WRITE_IO_LOG;
else
size = 1 << inode->i_blkbits;
}
else if (create && (offset >= inode->i_size))
size = 1 << XFS_WRITE_IO_LOG;
else
size = 1 << inode->i_blkbits;
VOP_BMAP(vp, offset, size,
create ? flags : PBF_READ,
......@@ -534,15 +543,20 @@ linvfs_get_block_core(
page_buf_daddr_t bn;
loff_t delta;
delta = offset - pbmap.pbm_offset;
delta >>= inode->i_blkbits;
/* For unwritten extents do not report a disk address on
* the read case.
*/
if (create || ((pbmap.pbm_flags & PBMF_UNWRITTEN) == 0)) {
delta = offset - pbmap.pbm_offset;
delta >>= inode->i_blkbits;
bn = pbmap.pbm_bn >> (inode->i_blkbits - 9);
bn += delta;
bn = pbmap.pbm_bn >> (inode->i_blkbits - 9);
bn += delta;
bh_result->b_blocknr = bn;
bh_result->b_bdev = pbmap.pbm_target->pbr_bdev;
set_buffer_mapped(bh_result);
bh_result->b_blocknr = bn;
bh_result->b_bdev = pbmap.pbm_target->pbr_bdev;
set_buffer_mapped(bh_result);
}
}
/* If we previously allocated a block out beyond eof and
......
This diff is collapsed.
......@@ -575,7 +575,7 @@ STATIC int
linvfs_setxattr(
struct dentry *dentry,
const char *name,
void *data,
const void *data,
size_t size,
int flags)
{
......@@ -593,13 +593,15 @@ linvfs_setxattr(
error = -ENOATTR;
p += xfs_namespaces[SYSTEM_NAMES].namelen;
if (strcmp(p, POSIXACL_ACCESS) == 0) {
error = xfs_acl_vset(vp, data, size, _ACL_TYPE_ACCESS);
error = xfs_acl_vset(vp, (void *) data, size,
_ACL_TYPE_ACCESS);
}
else if (strcmp(p, POSIXACL_DEFAULT) == 0) {
error = xfs_acl_vset(vp, data, size, _ACL_TYPE_DEFAULT);
error = xfs_acl_vset(vp, (void *) data, size,
_ACL_TYPE_DEFAULT);
}
else if (strcmp(p, POSIXCAP) == 0) {
error = xfs_cap_vset(vp, data, size);
error = xfs_cap_vset(vp, (void *) data, size);
}
if (!error) {
error = vn_revalidate(vp);
......@@ -619,7 +621,7 @@ linvfs_setxattr(
return -EPERM;
xflags |= ATTR_ROOT;
p += xfs_namespaces[ROOT_NAMES].namelen;
VOP_ATTR_SET(vp, p, data, size, xflags, NULL, error);
VOP_ATTR_SET(vp, p, (void *) data, size, xflags, NULL, error);
return -error;
}
if (strncmp(name, xfs_namespaces[USER_NAMES].name,
......@@ -627,7 +629,7 @@ linvfs_setxattr(
if (!capable_user_xattr(inode))
return -EPERM;
p += xfs_namespaces[USER_NAMES].namelen;
VOP_ATTR_SET(vp, p, data, size, xflags, NULL, error);
VOP_ATTR_SET(vp, p, (void *) data, size, xflags, NULL, error);
return -error;
}
return -ENOATTR;
......
......@@ -808,6 +808,25 @@ xfs_bdstrat_cb(struct xfs_buf *bp)
}
}
int
xfs_bmap(bhv_desc_t *bdp,
xfs_off_t offset,
ssize_t count,
int flags,
page_buf_bmap_t *pbmapp,
int *npbmaps)
{
xfs_inode_t *ip = XFS_BHVTOI(bdp);
xfs_iocore_t *io = &ip->i_iocore;
ASSERT((ip->i_d.di_mode & IFMT) == IFREG);
ASSERT(((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) != 0) ==
((ip->i_iocore.io_flags & XFS_IOCORE_RT) != 0));
return xfs_iomap(io, offset, count, flags, pbmapp, npbmaps);
}
/*
* Wrapper around bdstrat so that we can stop data
* from going to disk in case we are shutting down the filesystem.
......
......@@ -36,6 +36,8 @@ struct vnode;
struct bhv_desc;
struct xfs_mount;
struct xfs_iocore;
struct xfs_inode;
struct xfs_bmbt_irec;
struct page_buf_s;
struct page_buf_bmap_s;
......@@ -62,6 +64,16 @@ extern ssize_t xfs_sendfile (struct bhv_desc *, struct file *,
loff_t *, size_t, read_actor_t,
void *, struct cred *);
extern int xfs_iomap (struct xfs_iocore *, xfs_off_t, ssize_t, int,
struct page_buf_bmap_s *, int *);
extern int xfs_iomap_write_direct (struct xfs_inode *, loff_t, size_t,
int, struct xfs_bmbt_irec *, int *, int);
extern int xfs_iomap_write_delay (struct xfs_inode *, loff_t, size_t,
int, struct xfs_bmbt_irec *, int *);
extern int xfs_iomap_write_allocate (struct xfs_inode *,
struct xfs_bmbt_irec *, int *);
extern int xfs_iomap_write_unwritten (struct xfs_inode *, loff_t, size_t);
extern int xfs_dev_is_read_only (struct xfs_mount *, char *);
extern void XFS_log_write_unmount_ro (struct bhv_desc *);
......
......@@ -507,8 +507,15 @@ xfs_relse_buftarg(
truncate_inode_pages(btp->pbr_mapping, 0LL);
}
unsigned int
xfs_getsize_buftarg(
xfs_buftarg_t *btp)
{
return block_size(btp->pbr_bdev);
}
void
xfs_size_buftarg(
xfs_setsize_buftarg(
xfs_buftarg_t *btp,
unsigned int blocksize,
unsigned int sectorsize)
......@@ -535,7 +542,7 @@ xfs_alloc_buftarg(
btp->pbr_dev = bdev->bd_dev;
btp->pbr_bdev = bdev;
btp->pbr_mapping = bdev->bd_inode->i_mapping;
xfs_size_buftarg(btp, PAGE_CACHE_SIZE, bdev_hardsect_size(bdev));
xfs_setsize_buftarg(btp, PAGE_CACHE_SIZE, bdev_hardsect_size(bdev));
return btp;
}
......
......@@ -82,15 +82,17 @@ struct xfs_mount;
struct pb_target;
struct block_device;
extern void xfs_initialize_vnode (bhv_desc_t *, vnode_t *, bhv_desc_t *, int);
extern void xfs_initialize_vnode(bhv_desc_t *, vnode_t *, bhv_desc_t *, int);
extern int xfs_blkdev_get (struct xfs_mount *, const char *,
extern int xfs_blkdev_get(struct xfs_mount *, const char *,
struct block_device **);
extern void xfs_blkdev_put (struct block_device *);
extern void xfs_blkdev_put(struct block_device *);
extern struct pb_target *xfs_alloc_buftarg (struct block_device *);
extern void xfs_size_buftarg (struct pb_target *, unsigned int, unsigned int);
extern void xfs_relse_buftarg (struct pb_target *);
extern void xfs_free_buftarg (struct pb_target *);
extern struct pb_target *xfs_alloc_buftarg(struct block_device *);
extern void xfs_relse_buftarg(struct pb_target *);
extern void xfs_free_buftarg(struct pb_target *);
extern void xfs_setsize_buftarg(struct pb_target *, unsigned int, unsigned int);
extern unsigned int xfs_getsize_buftarg(struct pb_target *);
#endif /* __XFS_SUPER_H__ */
......@@ -48,9 +48,6 @@
#include <linux/buffer_head.h>
#include <linux/uio.h>
enum xfs_buffer_state { BH_Delay = BH_PrivateStart };
BUFFER_FNS(Delay, delay);
/*
* Turn this on to get pagebuf lock ownership
#define PAGEBUF_LOCK_TRACKING
......@@ -83,7 +80,7 @@ typedef enum { /* pbm_flags values */
PBMF_HOLE = 0x02, /* mapping covers a hole */
PBMF_DELAY = 0x04, /* mapping covers delalloc region */
PBMF_UNWRITTEN = 0x20 /* mapping covers allocated */
/* but uninitialized XFS data */
/* but uninitialized file data */
} bmap_flags_t;
typedef enum page_buf_flags_e { /* pb_flags values */
......@@ -105,19 +102,17 @@ typedef enum page_buf_flags_e { /* pb_flags values */
PBF_TRYLOCK = (1 << 14), /* lock requested, but do not wait */
PBF_FILE_ALLOCATE = (1 << 15), /* allocate all file space */
PBF_DONT_BLOCK = (1 << 16), /* do not block in current thread */
PBF_DIRECT = (1 << 17), /* direct I/O desired */
PBF_DIRECT = (1 << 17), /* direct I/O desired */
PBF_FILE_UNWRITTEN = (1 << 18), /* convert unwritten extent space */
/* flags used only internally */
_PBF_LOCKABLE = (1 << 19), /* page_buf_t may be locked */
_PBF_ALL_PAGES_MAPPED = (1 << 21),
/* all pages in rage are mapped */
_PBF_ADDR_ALLOCATED = (1 << 22),
/* pb_addr space was allocated */
_PBF_MEM_ALLOCATED = (1 << 23),
/* pb_mem and underlying pages allocated */
_PBF_ALL_PAGES_MAPPED = (1 << 21), /* all pages in range mapped */
_PBF_ADDR_ALLOCATED = (1 << 22), /* pb_addr space was allocated */
_PBF_MEM_ALLOCATED = (1 << 23), /* pb_mem+underlying pages alloc'd */
PBF_FORCEIO = (1 << 24),
PBF_FLUSH = (1 << 25), /* flush disk write cache */
PBF_FLUSH = (1 << 25), /* flush disk write cache */
PBF_READ_AHEAD = (1 << 26),
} page_buf_flags_t;
......
......@@ -104,8 +104,8 @@ int xfs_alloc_block_minrecs(int lev, struct xfs_btree_cur *cur);
#define XFS_MAX_BLOCKSIZE_LOG 16 /* i.e. 65536 bytes */
#define XFS_MIN_BLOCKSIZE (1 << XFS_MIN_BLOCKSIZE_LOG)
#define XFS_MAX_BLOCKSIZE (1 << XFS_MAX_BLOCKSIZE_LOG)
#define XFS_MIN_SECTORSIZE_LOG 9 /* i.e. 512 bytes */
#define XFS_MAX_SECTORSIZE_LOG 15 /* i.e. 32768 bytes */
#define XFS_MIN_SECTORSIZE_LOG 9 /* i.e. 512 bytes */
#define XFS_MAX_SECTORSIZE_LOG 15 /* i.e. 32768 bytes */
#define XFS_MIN_SECTORSIZE (1 << XFS_MIN_SECTORSIZE_LOG)
#define XFS_MAX_SECTORSIZE (1 << XFS_MAX_SECTORSIZE_LOG)
......
......@@ -35,28 +35,34 @@
/* These are just for xfs_syncsub... it sets an internal variable
* then passes it to VOP_FLUSH_PAGES or adds the flags to a newly gotten buf_t
*/
#define XFS_B_ASYNC PBF_ASYNC
#define XFS_B_DELWRI PBF_DELWRI
#define XFS_B_READ PBF_READ
#define XFS_B_WRITE PBF_WRITE
#define XFS_B_STALE PBF_STALE
#define XFS_B_ASYNC PBF_ASYNC
#define XFS_B_DELWRI PBF_DELWRI
#define XFS_B_READ PBF_READ
#define XFS_B_WRITE PBF_WRITE
#define XFS_B_STALE PBF_STALE
#define XFS_BUF_TRYLOCK PBF_TRYLOCK
#define XFS_INCORE_TRYLOCK PBF_TRYLOCK
#define XFS_BUF_LOCK PBF_LOCK
#define XFS_BUF_MAPPED PBF_MAPPED
#define BUF_BUSY PBF_DONT_BLOCK
#define BUF_BUSY PBF_DONT_BLOCK
#define XFS_BUF_BFLAGS(x) ((x)->pb_flags) /* debugging routines might need this */
#define XFS_BUF_BFLAGS(x) ((x)->pb_flags)
#define XFS_BUF_ZEROFLAGS(x) \
((x)->pb_flags &= ~(PBF_READ|PBF_WRITE|PBF_ASYNC|PBF_SYNC|PBF_DELWRI))
#define XFS_BUF_STALE(x) ((x)->pb_flags |= XFS_B_STALE)
#define XFS_BUF_UNSTALE(x) ((x)->pb_flags &= ~XFS_B_STALE)
#define XFS_BUF_ISSTALE(x) ((x)->pb_flags & XFS_B_STALE)
#define XFS_BUF_SUPER_STALE(x) (x)->pb_flags |= XFS_B_STALE;\
xfs_buf_undelay(x);\
(x)->pb_flags &= ~(PBF_PARTIAL|PBF_NONE)
#define XFS_BUF_STALE(x) ((x)->pb_flags |= XFS_B_STALE)
#define XFS_BUF_UNSTALE(x) ((x)->pb_flags &= ~XFS_B_STALE)
#define XFS_BUF_ISSTALE(x) ((x)->pb_flags & XFS_B_STALE)
#define XFS_BUF_SUPER_STALE(x) do { \
XFS_BUF_STALE(x); \
xfs_buf_undelay(x); \
XFS_BUF_DONE(x); \
} while (0)
#define XFS_BUF_MANAGE PBF_FS_MANAGED
#define XFS_BUF_UNMANAGE(x) ((x)->pb_flags &= ~PBF_FS_MANAGED)
static inline void xfs_buf_undelay(page_buf_t *pb)
{
......
......@@ -164,13 +164,6 @@ xfs_dm_send_data_event(
int flags,
vrwlock_t *locktype);
extern int
xfs_dm_send_create_event(
bhv_desc_t *dir_bdp,
char *name,
mode_t new_mode,
int *good_event_sent);
extern int
xfs_dm_send_mmap_event(
struct vm_area_struct *vma,
......@@ -249,16 +242,6 @@ typedef enum {
* Stubs for XFS DMAPI utility routines.
*/
static __inline int
xfs_dm_send_create_event(
bhv_desc_t *dir_bdp,
char *name,
mode_t new_mode,
int *good_event_sent)
{
return 0;
}
static __inline int
xfs_dm_send_data_event(
dm_eventtype_t event,
......
......@@ -246,9 +246,7 @@ xfs_iget_core(
/*
* Read the disk inode attributes into a new inode structure and get
* a new vnode for it. Initialize the inode lock so we can idestroy
* it soon if it's a dup. This should also initialize i_ino, i_bno,
* i_mount, and i_index.
* a new vnode for it. This should also initialize i_ino and i_mount.
*/
error = xfs_iread(mp, tp, ino, &ip, bno);
if (error) {
......
......@@ -142,7 +142,7 @@ xfs_inobp_bwcheck(xfs_buf_t *bp)
}
if (INT_ISZERO(dip->di_next_unlinked, ARCH_CONVERT)) {
cmn_err(CE_WARN,
"Bad next_unlinked field (0) in XFS inode buffer 0x%x, starting blockno %Ld, offset 0x%x",
"Bad next_unlinked field (0) in XFS inode buffer 0x%p, starting blockno %Ld, offset 0x%x",
(__uint64_t)(__psunsigned_t) bp,
(__int64_t) XFS_BUF_ADDR(bp),
xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize));
......
......@@ -41,14 +41,24 @@ xfs_size_fn(
}
xfs_ioops_t xfs_iocore_xfs = {
.xfs_ioinit = (xfs_ioinit_t) fs_noerr,
.xfs_bmapi_func = (xfs_bmapi_t) xfs_bmapi,
.xfs_bmap_eof_func = (xfs_bmap_eof_t) xfs_bmap_eof,
.xfs_iomap_write_direct =
(xfs_iomap_write_direct_t) xfs_iomap_write_direct,
.xfs_iomap_write_delay =
(xfs_iomap_write_delay_t) xfs_iomap_write_delay,
.xfs_iomap_write_allocate =
(xfs_iomap_write_allocate_t) xfs_iomap_write_allocate,
.xfs_iomap_write_unwritten =
(xfs_iomap_write_unwritten_t) xfs_iomap_write_unwritten,
.xfs_ilock = (xfs_lock_t) xfs_ilock,
.xfs_lck_map_shared = (xfs_lck_map_shared_t) xfs_ilock_map_shared,
.xfs_ilock_demote = (xfs_lock_demote_t) xfs_ilock_demote,
.xfs_ilock_nowait = (xfs_lock_nowait_t) xfs_ilock_nowait,
.xfs_unlock = (xfs_unlk_t) xfs_iunlock,
.xfs_size_func = (xfs_size_t) xfs_size_fn,
.xfs_lastbyte = (xfs_lastbyte_t) xfs_file_last_byte,
.xfs_iodone = (xfs_iodone_t) fs_noerr,
};
void
......@@ -83,4 +93,3 @@ xfs_iocore_inode_init(
xfs_iocore_inode_reinit(ip);
}
......@@ -419,42 +419,64 @@ xfs_xlatesb(
int
xfs_readsb(xfs_mount_t *mp)
{
unsigned int sector_size;
unsigned int extra_flags;
xfs_buf_t *bp;
xfs_sb_t *sbp;
int error = 0;
int error;
ASSERT(mp->m_sb_bp == 0);
ASSERT(mp->m_sb_bp == NULL);
ASSERT(mp->m_ddev_targp != NULL);
/*
* Allocate a (locked) buffer to hold the superblock.
* This will be kept around at all time to optimize
* This will be kept around at all times to optimize
* access to the superblock.
*/
bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 1,
PBF_LOCK|PBF_READ|PBF_MAPPED|PBF_MAPPABLE|PBF_FS_MANAGED);
ASSERT(bp != NULL);
ASSERT(XFS_BUF_ISBUSY(bp) && XFS_BUF_VALUSEMA(bp) <= 0);
sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
extra_flags = XFS_BUF_LOCK | XFS_BUF_MANAGE | XFS_BUF_MAPPED;
bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
BTOBB(sector_size), extra_flags);
ASSERT(bp);
ASSERT(XFS_BUF_ISBUSY(bp));
ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
/*
* Initialize the mount structure from the superblock.
* But first do some basic consistency checking.
*/
sbp = XFS_BUF_TO_SBP(bp);
xfs_xlatesb(XFS_BUF_PTR(bp), &(mp->m_sb), 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
if ((error = xfs_mount_validate_sb(mp, &(mp->m_sb)))) {
xfs_xlatesb(XFS_BUF_PTR(bp), &(mp->m_sb), 1,
ARCH_CONVERT, XFS_SB_ALL_BITS);
error = xfs_mount_validate_sb(mp, &(mp->m_sb));
if (error) {
cmn_err(CE_WARN, "XFS: SB validate failed");
goto err;
XFS_BUF_UNMANAGE(bp);
xfs_buf_relse(bp);
return error;
}
/*
* Re-read the superblock so that our buffer is correctly sized.
* We only need to do this if sector size on-disk is different.
*/
if (sector_size != mp->m_sb.sb_sectsize) {
XFS_BUF_UNMANAGE(bp);
xfs_buf_relse(bp);
sector_size = mp->m_sb.sb_sectsize;
bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
BTOBB(sector_size), extra_flags);
ASSERT(bp);
ASSERT(XFS_BUF_ISBUSY(bp));
ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
}
mp->m_sb_bp = bp;
xfs_buf_relse(bp);
ASSERT(XFS_BUF_VALUSEMA(bp) > 0);
return 0;
err:
bp->pb_flags &= ~PBF_FS_MANAGED;
xfs_buf_relse(bp);
return error;
}
......@@ -1531,10 +1553,10 @@ xfs_freesb(
/*
* Use xfs_getsb() so that the buffer will be locked
* when we call nfreerbuf().
* when we call xfs_buf_relse().
*/
bp = xfs_getsb(mp, 0);
bp->pb_flags &= ~PBF_FS_MANAGED;
XFS_BUF_UNMANAGE(bp);
xfs_buf_relse(bp);
mp->m_sb_bp = NULL;
}
......
......@@ -87,41 +87,60 @@ struct xfs_bmap_free;
#define AIL_LOCK(mp,s) s=mutex_spinlock(&(mp)->m_ail_lock)
#define AIL_UNLOCK(mp,s) mutex_spinunlock(&(mp)->m_ail_lock, s)
/* Prototypes and functions for I/O core modularization, a vector
* of functions is used to indirect from xfs/cxfs independent code
* to the xfs/cxfs dependent code.
* The vector is placed in the mount structure so that we can
* minimize the number of memory indirections involved.
/*
* Prototypes and functions for I/O core modularization.
*/
struct flid;
struct buf;
typedef int (*xfs_ioinit_t)(struct vfs *,
struct xfs_mount_args *, int *);
typedef int (*xfs_bmapi_t)(struct xfs_trans *, void *,
xfs_fileoff_t, xfs_filblks_t, int,
xfs_fsblock_t *, xfs_extlen_t,
struct xfs_bmbt_irec *, int *,
struct xfs_bmap_free *);
typedef int (*xfs_bmap_eof_t)(void *, xfs_fileoff_t, int, int *);
typedef int (*xfs_iomap_write_direct_t)(
void *, loff_t, size_t, int,
struct xfs_bmbt_irec *, int *, int);
typedef int (*xfs_iomap_write_delay_t)(
void *, loff_t, size_t, int,
struct xfs_bmbt_irec *, int *);
typedef int (*xfs_iomap_write_allocate_t)(
void *, struct xfs_bmbt_irec *, int *);
typedef int (*xfs_iomap_write_unwritten_t)(
void *, loff_t, size_t);
typedef uint (*xfs_lck_map_shared_t)(void *);
typedef void (*xfs_lock_t)(void *, uint);
typedef void (*xfs_lock_demote_t)(void *, uint);
typedef int (*xfs_lock_nowait_t)(void *, uint);
typedef void (*xfs_unlk_t)(void *, unsigned int);
typedef void (*xfs_chgtime_t)(void *, int);
typedef xfs_fsize_t (*xfs_size_t)(void *);
typedef xfs_fsize_t (*xfs_lastbyte_t)(void *);
typedef xfs_fsize_t (*xfs_iodone_t)(struct vfs *);
typedef struct xfs_ioops {
xfs_bmapi_t xfs_bmapi_func;
xfs_bmap_eof_t xfs_bmap_eof_func;
xfs_lock_t xfs_ilock;
xfs_lock_demote_t xfs_ilock_demote;
xfs_lock_nowait_t xfs_ilock_nowait;
xfs_unlk_t xfs_unlock;
xfs_chgtime_t xfs_chgtime;
xfs_size_t xfs_size_func;
xfs_lastbyte_t xfs_lastbyte;
xfs_ioinit_t xfs_ioinit;
xfs_bmapi_t xfs_bmapi_func;
xfs_bmap_eof_t xfs_bmap_eof_func;
xfs_iomap_write_direct_t xfs_iomap_write_direct;
xfs_iomap_write_delay_t xfs_iomap_write_delay;
xfs_iomap_write_allocate_t xfs_iomap_write_allocate;
xfs_iomap_write_unwritten_t xfs_iomap_write_unwritten;
xfs_lock_t xfs_ilock;
xfs_lck_map_shared_t xfs_lck_map_shared;
xfs_lock_demote_t xfs_ilock_demote;
xfs_lock_nowait_t xfs_ilock_nowait;
xfs_unlk_t xfs_unlock;
xfs_size_t xfs_size_func;
xfs_iodone_t xfs_iodone;
} xfs_ioops_t;
#define XFS_IOINIT(vfsp, args, flags) \
(*(mp)->m_io_ops.xfs_ioinit)(vfsp, args, flags)
#define XFS_BMAPI(mp, trans,io,bno,len,f,first,tot,mval,nmap,flist) \
(*(mp)->m_io_ops.xfs_bmapi_func) \
(trans,(io)->io_obj,bno,len,f,first,tot,mval,nmap,flist)
......@@ -130,9 +149,31 @@ typedef struct xfs_ioops {
(*(mp)->m_io_ops.xfs_bmap_eof_func) \
((io)->io_obj, endoff, whichfork, eof)
#define XFS_IOMAP_WRITE_DIRECT(mp, io, offset, count, flags, mval, nmap, found)\
(*(mp)->m_io_ops.xfs_iomap_write_direct) \
((io)->io_obj, offset, count, flags, mval, nmap, found)
#define XFS_IOMAP_WRITE_DELAY(mp, io, offset, count, flags, mval, nmap) \
(*(mp)->m_io_ops.xfs_iomap_write_delay) \
((io)->io_obj, offset, count, flags, mval, nmap)
#define XFS_IOMAP_WRITE_ALLOCATE(mp, io, mval, nmap) \
(*(mp)->m_io_ops.xfs_iomap_write_allocate) \
((io)->io_obj, mval, nmap)
#define XFS_IOMAP_WRITE_UNWRITTEN(mp, io, offset, count) \
(*(mp)->m_io_ops.xfs_iomap_write_unwritten) \
((io)->io_obj, offset, count)
#define XFS_LCK_MAP_SHARED(mp, io) \
(*(mp)->m_io_ops.xfs_lck_map_shared)((io)->io_obj)
#define XFS_ILOCK(mp, io, mode) \
(*(mp)->m_io_ops.xfs_ilock)((io)->io_obj, mode)
#define XFS_ILOCK_NOWAIT(mp, io, mode) \
(*(mp)->m_io_ops.xfs_ilock_nowait)((io)->io_obj, mode)
#define XFS_IUNLOCK(mp, io, mode) \
(*(mp)->m_io_ops.xfs_unlock)((io)->io_obj, mode)
......@@ -142,8 +183,13 @@ typedef struct xfs_ioops {
#define XFS_SIZE(mp, io) \
(*(mp)->m_io_ops.xfs_size_func)((io)->io_obj)
#define XFS_LASTBYTE(mp, io) \
(*(mp)->m_io_ops.xfs_lastbyte)((io)->io_obj)
#define XFS_IODONE(vfsp) \
(*(mp)->m_io_ops.xfs_iodone)(vfsp)
/*
* Prototypes and functions for the XFS realtime subsystem.
*/
typedef struct xfs_mount {
......@@ -303,8 +349,8 @@ typedef struct xfs_mount {
/*
* Default minimum read and write sizes.
*/
#define XFS_READIO_LOG_LARGE 12
#define XFS_WRITEIO_LOG_LARGE 12
#define XFS_READIO_LOG_LARGE 16
#define XFS_WRITEIO_LOG_LARGE 16
/*
* Default allocation size
*/
......
......@@ -2287,7 +2287,7 @@ xfs_rtmount_init(
return XFS_ERROR(E2BIG);
}
error = xfs_read_buf(mp, mp->m_rtdev_targp,
XFS_FSB_TO_BB(mp, d - 1),
d - XFS_FSB_TO_BB(mp, 1),
XFS_FSB_TO_BB(mp, 1), 0, &bp);
if (error) {
cmn_err(CE_WARN,
......
......@@ -97,7 +97,7 @@ xfs_do_force_shutdown(
if (!(flags & XFS_FORCE_UMOUNT)) {
cmn_err(CE_NOTE,
"xfs_force_shutdown(%s,0x%x) called from line %d of file %s. Return address = 0x%x",
"xfs_force_shutdown(%s,0x%x) called from line %d of file %s. Return address = 0x%p",
mp->m_fsname,flags,lnnum,fname,__return_address);
}
/*
......
......@@ -472,7 +472,7 @@ xfs_trans_read_buf(
*/
#if defined(DEBUG)
if (XFS_BUF_ISSTALE(bp) && XFS_BUF_ISDELAYWRITE(bp))
cmn_err(CE_NOTE, "about to pop assert, bp == 0x%x", bp);
cmn_err(CE_NOTE, "about to pop assert, bp == 0x%p", bp);
#endif
ASSERT((XFS_BUF_BFLAGS(bp) & (XFS_B_STALE|XFS_B_DELWRI)) !=
(XFS_B_STALE|XFS_B_DELWRI));
......
......@@ -451,18 +451,19 @@ xfs_mount(
goto error;
}
xfs_size_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize,
mp->m_sb.sb_sectsize);
xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize,
mp->m_sb.sb_sectsize);
if (logdev && logdev != ddev) {
unsigned int ss = BBSIZE;
unsigned int log_sector_size = BBSIZE;
if (XFS_SB_VERSION_HASSECTOR(&mp->m_sb))
ss = mp->m_sb.sb_logsectsize;
xfs_size_buftarg(mp->m_logdev_targp, mp->m_sb.sb_blocksize, ss);
log_sector_size = mp->m_sb.sb_logsectsize;
xfs_setsize_buftarg(mp->m_logdev_targp, mp->m_sb.sb_blocksize,
log_sector_size);
}
if (rtdev)
xfs_size_buftarg(mp->m_rtdev_targp, mp->m_sb.sb_blocksize,
mp->m_sb.sb_blocksize);
xfs_setsize_buftarg(mp->m_rtdev_targp, mp->m_sb.sb_blocksize,
mp->m_sb.sb_blocksize);
error = xfs_mountfs(vfsp, mp, ddev->bd_dev, flags);
if (error)
......
......@@ -44,15 +44,6 @@ extern int xfs_ioctl(bhv_desc_t *, struct inode *, struct file *,
unsigned int, unsigned long);
#ifdef XFS_RW_TRACE
STATIC void
xfs_ctrunc_trace(
int tag,
xfs_inode_t *ip);
#else
#define xfs_ctrunc_trace(tag, ip)
#endif /* DEBUG */
/*
* For xfs, we check that the file isn't too big to be opened by this kernel.
* No other open action is required for regular files. Devices are handled
......@@ -1880,7 +1871,6 @@ xfs_lookup(
cred_t *credp)
{
xfs_inode_t *dp, *ip;
struct vnode *vp;
xfs_ino_t e_inum;
int error;
uint lock_mode;
......@@ -1896,58 +1886,19 @@ xfs_lookup(
lock_mode = xfs_ilock_map_shared(dp);
error = xfs_dir_lookup_int(dir_bdp, lock_mode, dentry, &e_inum, &ip);
if (error) {
xfs_iunlock_map_shared(dp, lock_mode);
return error;
if (!error) {
*vpp = XFS_ITOV(ip);
ITRACE(ip);
}
vp = XFS_ITOV(ip);
ITRACE(ip);
xfs_iunlock_map_shared(dp, lock_mode);
*vpp = vp;
return 0;
return error;
}
#ifdef XFS_RW_TRACE
STATIC void
xfs_ctrunc_trace(
int tag,
xfs_inode_t *ip)
{
if (ip->i_rwtrace == NULL) {
return;
}
ktrace_enter(ip->i_rwtrace,
(void*)((long)tag),
(void*)ip,
(void*)((long)private.p_cpuid),
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0,
(void*)0);
}
#endif /* XFS_RW_TRACE */
#define XFS_CREATE_NEW_MAXTRIES 10000
/*
* xfs_create (create a new file).
* It might still find name exists out there, though.
* But vpp, doens't point at a vnode.
*/
STATIC int
xfs_create(
......@@ -1968,7 +1919,6 @@ xfs_create(
xfs_bmap_free_t free_list;
xfs_fsblock_t first_block;
boolean_t dp_joined_to_trans;
int dm_event_sent = 0;
uint cancel_flags;
int committed;
xfs_prid_t prid;
......@@ -1989,8 +1939,10 @@ xfs_create(
return XFS_ERROR(ENAMETOOLONG);
if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
error = xfs_dm_send_create_event(dir_bdp, name,
dm_di_mode, &dm_event_sent);
error = dm_send_namesp_event(DM_EVENT_CREATE,
dir_bdp, DM_RIGHT_NULL, NULL,
DM_RIGHT_NULL, name, NULL,
dm_di_mode, 0, 0);
if (error)
return error;
}
......@@ -2161,7 +2113,7 @@ xfs_create(
/* Fallthrough to std_return with error = 0 */
std_return:
if ((error != 0 && dm_event_sent != 0) &&
if ((error != 0) &&
DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
DM_EVENT_POSTCREATE)) {
(void) dm_send_namesp_event(DM_EVENT_POSTCREATE,
......@@ -2227,16 +2179,7 @@ int xfs_rm_attempts;
* vnode ref count will still include that from the .. entry in
* this case.
*
* The inode passed in will have been looked up using xfs_get_dir_entry().
* Since that lookup the directory lock will have been dropped, so
* we need to validate that the inode given is still pointed to by the
* directory. We use the directory inode in memory generation count
* as an optimization to tell if a new lookup is necessary. If the
* directory no longer points to the given inode with the given name,
* then we drop the directory lock, set the entry_changed parameter to 1,
* and return. It is up to the caller to drop the reference to the inode.
*
* There is a dealock we need to worry about. If the locked directory is
* There is a deadlock we need to worry about. If the locked directory is
* in the AIL, it might be blocking up the log. The next inode we lock
* could be already locked by another thread waiting for log space (e.g
* a permanent log reservation with a long running transaction (see
......@@ -2249,8 +2192,7 @@ STATIC int
xfs_lock_dir_and_entry(
xfs_inode_t *dp,
vname_t *dentry,
xfs_inode_t *ip, /* inode of entry 'name' */
int *entry_changed)
xfs_inode_t *ip) /* inode of entry 'name' */
{
int attempts;
xfs_ino_t e_inum;
......@@ -2263,7 +2205,6 @@ xfs_lock_dir_and_entry(
attempts = 0;
again:
*entry_changed = 0;
xfs_ilock(dp, XFS_ILOCK_EXCL);
e_inum = ip->i_ino;
......@@ -2477,7 +2418,6 @@ xfs_remove(
xfs_fsblock_t first_block;
int cancel_flags;
int committed;
int entry_changed;
int dm_di_mode = 0;
int link_zero;
uint resblks;
......@@ -2504,7 +2444,6 @@ xfs_remove(
}
/* From this point on, return through std_return */
retry:
ip = NULL;
/*
......@@ -2571,7 +2510,7 @@ xfs_remove(
return error;
}
error = xfs_lock_dir_and_entry(dp, dentry, ip, &entry_changed);
error = xfs_lock_dir_and_entry(dp, dentry, ip);
if (error) {
REMOVE_DEBUG_TRACE(__LINE__);
xfs_trans_cancel(tp, cancel_flags);
......@@ -2579,17 +2518,6 @@ xfs_remove(
goto std_return;
}
/*
* If the inode we found in the first pass is no longer
* the entry with the given name, then drop our transaction and
* inode reference and start over.
*/
if (entry_changed) {
xfs_trans_cancel(tp, cancel_flags);
IRELE(ip);
goto retry;
}
/*
* At this point, we've gotten both the directory and the entry
* inodes locked.
......@@ -2610,28 +2538,6 @@ xfs_remove(
goto error_return;
}
if ((ip->i_d.di_mode & IFMT) == IFDIR) {
error = XFS_ERROR(EPERM);
REMOVE_DEBUG_TRACE(__LINE__);
goto error_return;
}
/*
* Return error when removing . and ..
*/
if (name[0] == '.') {
if (name[1] == '\0') {
error = XFS_ERROR(EINVAL);
REMOVE_DEBUG_TRACE(__LINE__);
goto error_return;
}
else if (name[1] == '.' && name[2] == '\0') {
error = XFS_ERROR(EEXIST);
REMOVE_DEBUG_TRACE(__LINE__);
goto error_return;
}
}
/*
* Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
*/
......@@ -2696,8 +2602,7 @@ xfs_remove(
IRELE(ip);
/* Fall through to std_return with error = 0 */
std_return:
std_return:
if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp,
DM_EVENT_POSTREMOVE)) {
(void) dm_send_namesp_event(DM_EVENT_POSTREMOVE,
......@@ -2938,7 +2843,6 @@ xfs_mkdir(
vnode_t *dir_vp;
boolean_t dp_joined_to_trans;
boolean_t created = B_FALSE;
int dm_event_sent = 0;
xfs_prid_t prid;
xfs_dquot_t *udqp, *gdqp;
uint resblks;
......@@ -2961,8 +2865,10 @@ xfs_mkdir(
dm_di_mode = vap->va_mode|VTTOIF(vap->va_type);
if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
error = xfs_dm_send_create_event(dir_bdp, dir_name,
dm_di_mode, &dm_event_sent);
error = dm_send_namesp_event(DM_EVENT_CREATE,
dir_bdp, DM_RIGHT_NULL, NULL,
DM_RIGHT_NULL, dir_name, NULL,
dm_di_mode, 0, 0);
if (error)
return error;
}
......@@ -3127,7 +3033,7 @@ xfs_mkdir(
* xfs_trans_commit. */
std_return:
if ( (created || (error != 0 && dm_event_sent != 0)) &&
if ( (created || (error != 0)) &&
DM_EVENT_ENABLED(dir_vp->v_vfsp, XFS_BHVTOI(dir_bdp),
DM_EVENT_POSTCREATE)) {
(void) dm_send_namesp_event(DM_EVENT_POSTCREATE,
......@@ -3180,7 +3086,6 @@ xfs_rmdir(
xfs_fsblock_t first_block;
int cancel_flags;
int committed;
int entry_changed;
vnode_t *dir_vp;
int dm_di_mode = 0;
int last_cdp_link;
......@@ -3209,7 +3114,6 @@ xfs_rmdir(
/* Return through std_return after this point. */
retry:
cdp = NULL;
/*
......@@ -3281,24 +3185,13 @@ xfs_rmdir(
* that the directory entry for the child directory inode has
* not changed while we were obtaining a log reservation.
*/
error = xfs_lock_dir_and_entry(dp, dentry, cdp, &entry_changed);
error = xfs_lock_dir_and_entry(dp, dentry, cdp);
if (error) {
xfs_trans_cancel(tp, cancel_flags);
IRELE(cdp);
goto std_return;
}
/*
* If the inode we found in the first pass is no longer
* the entry with the given name, then drop our transaction and
* inode reference and start over.
*/
if (entry_changed) {
xfs_trans_cancel(tp, cancel_flags);
IRELE(cdp);
goto retry;
}
xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
if (dp != cdp) {
/*
......@@ -3455,20 +3348,12 @@ xfs_readdir(
}
lock_mode = xfs_ilock_map_shared(dp);
if ((dp->i_d.di_mode & IFMT) != IFDIR) {
xfs_iunlock_map_shared(dp, lock_mode);
return XFS_ERROR(ENOTDIR);
}
start_offset = uiop->uio_offset;
error = XFS_DIR_GETDENTS(dp->i_mount, tp, dp, uiop, eofp);
if (start_offset != uiop->uio_offset) {
xfs_ichgtime(dp, XFS_ICHGTIME_ACC);
}
xfs_iunlock_map_shared(dp, lock_mode);
return error;
}
......
......@@ -1637,9 +1637,9 @@ static void printinode(struct inode *ip)
if (ip == NULL)
return;
kdb_printf(" i_ino = %lu i_count = %u i_dev = 0x%x i_size %Ld\n",
kdb_printf(" i_ino = %lu i_count = %u i_size %Ld\n",
ip->i_ino, atomic_read(&ip->i_count),
ip->i_sb->s_dev, ip->i_size);
ip->i_size);
kdb_printf(
" i_mode = 0x%x i_nlink = %d i_rdev = 0x%x i_state = 0x%lx\n",
......
......@@ -22,6 +22,7 @@ enum bh_state_bits {
BH_New, /* Disk mapping was newly created by get_block */
BH_Async_Read, /* Is under end_buffer_async_read I/O */
BH_Async_Write, /* Is under end_buffer_async_write I/O */
BH_Delay, /* Buffer is not yet allocated on disk */
BH_Boundary, /* Block is followed by a discontiguity */
BH_PrivateStart,/* not a state bit, but the first bit available
......@@ -105,6 +106,7 @@ BUFFER_FNS(Mapped, mapped)
BUFFER_FNS(New, new)
BUFFER_FNS(Async_Read, async_read)
BUFFER_FNS(Async_Write, async_write)
BUFFER_FNS(Delay, delay);
BUFFER_FNS(Boundary, boundary)
#define bh_offset(bh) ((unsigned long)(bh)->b_data & ~PAGE_MASK)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment