#
PKG_MAJOR=2
PKG_MINOR=3
-PKG_REVISION=4
+PKG_REVISION=5
PKG_BUILD=0
+xfsprogs (2.3.5-1) unstable; urgency=low
+
+ * New upstream release
+ * Fix mkfs bug, patch from Anton Blanchard (closes: #163897)
+
+ -- Nathan Scott <nathans@debian.org> Mon, 7 Oct 2002 05:19:51 +1000
+
xfsprogs (2.3.4-1) unstable; urgency=low
* New upstream release
+xfsprogs-2.3.5 (10 October 2002)
+ - Sync up user/kernel source in lib{xfs,xlog} and headers.
+ - Fix mkfs (libxfs) bug when using BLKFLSBUF ioctl - we passed
+ in the device number instead of a file descriptor (and EBADF
+ was the end result, which we ignored).
+ - Thanks to Anton Blanchard <anton@samba.org> for fixing this.
+
xfsprogs-2.3.4 (04 October 2002)
- - xfs_repair: fix size calculation bug in repair's memory allocation,
+ - Fix size calculation bug in xfs_repair's memory allocation,
reduces memory usage by a factor of 4.
xfsprogs-2.3.3 (16 September 2002)
# define ASSERT(EX) ((void) 0)
#endif
+#define IRIX_DEV_BITSMAJOR 14
+#define IRIX_DEV_BITSMINOR 18
+#define IRIX_DEV_MAXMAJ 0x1ff
+#define IRIX_DEV_MAXMIN 0x3ffff
+#define IRIX_DEV_MAJOR(dev) ((int)(((unsigned)(dev) >> IRIX_DEV_BITSMINOR) \
+ & IRIX_DEV_MAXMAJ))
+#define IRIX_DEV_MINOR(dev) ((int)((dev) & IRIX_DEV_MAXMIN))
+#define IRIX_MKDEV(major,minor) ((dev_t)(((major) << IRIX_DEV_BITSMINOR) \
+ | (minor&IRIX_DEV_MAXMIN)))
+#define IRIX_DEV_TO_KDEVT(dev) makedev(IRIX_DEV_MAJOR(dev),IRIX_DEV_MINOR(dev))
+
#endif /* __XFS_PLATFORM_DEFS_H__ */
#define DIRINO_COPY_ARCH(from,to,arch) \
if ((arch) == ARCH_NOCONVERT) { \
- bcopy(from,to,sizeof(xfs_ino_t)); \
+ memcpy(to,from,sizeof(xfs_ino_t)); \
} else { \
INT_SWAP_UNALIGNED_64(from,to); \
}
#define DIRINO4_COPY_ARCH(from,to,arch) \
if ((arch) == ARCH_NOCONVERT) { \
- bcopy((((__u8*)from+4)),to,sizeof(xfs_dir2_ino4_t)); \
+ memcpy(to,(((__u8*)from+4)),sizeof(xfs_dir2_ino4_t)); \
} else { \
INT_SWAP_UNALIGNED_32(from,to); \
}
* be calculated on the fly.
*
* Entries are packed toward the top as tightly as possible. The header
- * and the elements must be bcopy()'d out into a work area to get correct
+ * and the elements must be memcpy'd out into a work area to get correct
* alignment for the inode number fields.
*/
typedef struct xfs_dir2_sf_hdr {
* be calculated on the fly.
*
* Entries are packed toward the top as tight as possible. The header
- * and the elements much be bcopy()'d out into a work area to get correct
+ * and the elements much be memcpy'd out into a work area to get correct
* alignment for the inode number fields.
*/
typedef struct xfs_dir_shortform {
- (char *) &(handle)) \
+ (handle).ha_fid.xfs_fid_len)
-#define XFS_HANDLE_CMP(h1, h2) bcmp(h1, h2, sizeof (xfs_handle_t))
+#define XFS_HANDLE_CMP(h1, h2) memcmp(h1, h2, sizeof(xfs_handle_t))
-#define FSHSIZE sizeof (fsid_t)
+#define FSHSIZE sizeof(fsid_t)
/*
#define BTOBB(bytes) (((__u64)(bytes) + BBSIZE - 1) >> BBSHIFT)
#define BTOBBT(bytes) ((__u64)(bytes) >> BBSHIFT)
#define BBTOB(bbs) ((bbs) << BBSHIFT)
-#define OFFTOBB(bytes) (((__u64)(bytes) + BBSIZE - 1) >> BBSHIFT)
-#define OFFTOBBT(bytes) ((__u64)(bytes) >> BBSHIFT)
-#define BBTOOFF(bbs) ((__u64)(bbs) << BBSHIFT)
-
-#define SEEKLIMIT32 0x7fffffff
-#define BBSEEKLIMIT32 BTOBBT(SEEKLIMIT32)
-#define SEEKLIMIT 0x7fffffffffffffffLL
-#define BBSEEKLIMIT OFFTOBBT(SEEKLIMIT)
#endif /* _LINUX_XFS_FS_H */
struct xfs_mount;
struct xfs_trans;
struct xfs_dquot;
-struct pm;
/*
xfs_extlen_t xg_count_fsb;
} xfs_gap_t;
-/*
- * This structure is used to hold common pieces of the buffer
- * and file for xfs_dio_write and xfs_dio_read.
- */
-typedef struct xfs_dio {
- struct xfs_buf *xd_bp;
- bhv_desc_t *xd_bdp;
- struct xfs_inode *xd_ip;
- struct xfs_iocore *xd_io;
- struct cred *xd_cr;
- struct pm *xd_pmp;
- int xd_blkalgn;
- int xd_ioflag;
- xfs_off_t xd_start;
- size_t xd_length;
-} xfs_dio_t;
-
typedef struct dm_attrs_s {
__uint32_t da_dmevmask; /* DMIG event mask */
__uint16_t da_dmstate; /* DMIG state info */
void xfs_inode_lock_init(xfs_inode_t *, struct vnode *);
int xfs_iget(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
uint, xfs_inode_t **, xfs_daddr_t);
-int xfs_vn_iget(vfs_t *, struct vnode *, xfs_ino_t);
void xfs_iput(xfs_inode_t *, uint);
void xfs_iput_new(xfs_inode_t *, uint);
void xfs_ilock(xfs_inode_t *, uint);
xfs_inode_t **, xfs_daddr_t);
int xfs_iread_extents(struct xfs_trans *, xfs_inode_t *, int);
int xfs_ialloc(struct xfs_trans *, xfs_inode_t *, mode_t, nlink_t,
- dev_t, struct cred *, xfs_prid_t, int,
+ xfs_dev_t, struct cred *, xfs_prid_t, int,
struct xfs_buf **, boolean_t *, xfs_inode_t **);
void xfs_xlate_dinode_core(xfs_caddr_t, struct xfs_dinode_core *, int,
xfs_arch_t);
#define xfs_ipincount(ip) ((unsigned int) atomic_read(&ip->i_pincount))
-
+void xfs_revalidate_inode(struct xfs_mount *, vnode_t *vp, xfs_inode_t *);
#ifdef DEBUG
void xfs_isize_check(struct xfs_mount *, xfs_inode_t *, xfs_fsize_t);
struct xfs_perag;
struct xfs_quotainfo;
struct xfs_iocore;
-struct xfs_dio;
struct xfs_bmbt_irec;
struct xfs_bmap_free;
* minimize the number of memory indirections involved.
*/
-typedef int (*xfs_dio_write_t)(struct xfs_dio *);
-typedef int (*xfs_dio_read_t)(struct xfs_dio *);
-typedef int (*xfs_strat_write_t)(struct xfs_iocore *, struct xfs_buf *);
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_rsync_t)(void *, int, xfs_off_t, xfs_off_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_setsize_t)(void *, xfs_off_t);
typedef xfs_fsize_t (*xfs_lastbyte_t)(void *);
typedef struct xfs_ioops {
#define XFS_MOUNT_NOUUID 0x00004000 /* ignore uuid during mount */
#define XFS_MOUNT_32BITINODES 0x00008000 /* do not create inodes above
* 32 bits in size */
-#define XFS_MOUNT_IRIXSGID 0x00010000 /* Irix-style sgid inheritance */
-#define XFS_MOUNT_NOLOGFLUSH 0x00020000
+#define XFS_MOUNT_NOLOGFLUSH 0x00010000
/*
* Flags for m_cxfstype
void xfs_initialize_perag(xfs_mount_t *, int);
void xfs_xlatesb(void *, struct xfs_sb *, int, xfs_arch_t, __int64_t);
+int xfs_blkdev_get(const char *, struct block_device **);
+void xfs_blkdev_put(struct block_device *);
+struct xfs_buftarg *xfs_alloc_buftarg(struct block_device *);
+void xfs_free_buftarg(struct xfs_buftarg *);
+
/*
* Flags for freeze operations.
*/
#endif /* !CONFIG_PROC_FS */
-
-/* juggle IRIX device numbers - still used in ondisk structures */
-
-#ifndef __KERNEL__
-#define MKDEV(major, minor) makedev(major, minor)
-#endif
-
-#define IRIX_DEV_BITSMAJOR 14
-#define IRIX_DEV_BITSMINOR 18
-#define IRIX_DEV_MAXMAJ 0x1ff
-#define IRIX_DEV_MAXMIN 0x3ffff
-#define IRIX_DEV_MAJOR(dev) ((int)(((unsigned)(dev)>>IRIX_DEV_BITSMINOR) \
- & IRIX_DEV_MAXMAJ))
-#define IRIX_DEV_MINOR(dev) ((int)((dev)&IRIX_DEV_MAXMIN))
-#define IRIX_MKDEV(major,minor) ((xfs_dev_t)(((major)<<IRIX_DEV_BITSMINOR) \
- | (minor&IRIX_DEV_MAXMIN)))
-
-#define IRIX_DEV_TO_KDEVT(dev) MKDEV(IRIX_DEV_MAJOR(dev),IRIX_DEV_MINOR(dev))
+/*
+ * Juggle IRIX device numbers - still used in ondisk structures
+ */
+#define XFS_DEV_BITSMAJOR 14
+#define XFS_DEV_BITSMINOR 18
+#define XFS_DEV_MAXMAJ 0x1ff
+#define XFS_DEV_MAXMIN 0x3ffff
+#define XFS_DEV_MAJOR(dev) ((int)(((unsigned)(dev)>>XFS_DEV_BITSMINOR) \
+ & XFS_DEV_MAXMAJ))
+#define XFS_DEV_MINOR(dev) ((int)((dev)&XFS_DEV_MAXMIN))
+#define XFS_MKDEV(major,minor) ((xfs_dev_t)(((major)<<XFS_DEV_BITSMINOR) \
+ | (minor&XFS_DEV_MAXMIN)))
+
+#define XFS_DEV_TO_KDEVT(dev) mk_kdev(XFS_DEV_MAJOR(dev),XFS_DEV_MINOR(dev))
#endif /* !__XFS_TYPES_H */
* we're not opening a real device, in which case
* choose a new fake device number.
*/
- dev=(statb.st_rdev)?(statb.st_rdev):(nextfakedev--);
+ dev = (statb.st_rdev) ? (statb.st_rdev) : (nextfakedev--);
- for (d=0;d<MAX_DEVS;d++)
+ for (d = 0; d < MAX_DEVS; d++)
if (dev_map[d].dev == dev) {
fprintf(stderr, "%s: device %lld is already open\n",
progname, (long long)dev);
exit(1);
}
- for (d=0;d<MAX_DEVS;d++)
+ for (d = 0; d < MAX_DEVS; d++)
if (!dev_map[d].dev) {
- dev_map[d].dev=dev;
- dev_map[d].fd=fd;
+ dev_map[d].dev = dev;
+ dev_map[d].fd = fd;
return dev;
}
{
int d;
- for (d=0;d<MAX_DEVS;d++)
+ for (d = 0; d < MAX_DEVS; d++)
if (dev_map[d].dev == dev) {
- int fd;
+ int fd;
- fd=dev_map[d].dev;
- dev_map[d].dev=dev_map[d].fd=0;
+ fd = dev_map[d].fd;
+ dev_map[d].dev = dev_map[d].fd = 0;
fsync(fd);
ioctl(fd, BLKFLSBUF, 0);
progname, size, strerror(errno));
exit(1);
}
- bzero(z, size);
+ memset(z, 0, size);
fd = libxfs_device_to_fd(dev);
for (bno = start; bno < start + len; ) {
nblks = (uint)BTOBB(size);
ip->i_d.di_uid = cr->cr_uid;
ip->i_d.di_gid = cr->cr_gid;
ip->i_d.di_projid = prid;
- bzero(&(ip->i_d.di_pad[0]), sizeof(ip->i_d.di_pad));
+ memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
/*
* If the superblock version is up to where we support new format
XFS_DINODE_VERSION_2);
ip->i_d.di_onlink = 0;
INT_ZERO(dip->di_core.di_onlink, ARCH_CONVERT);
- bzero(&(ip->i_d.di_pad[0]), sizeof(ip->i_d.di_pad));
- bzero(&(dip->di_core.di_pad[0]),
+ memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
+ memset(&(dip->di_core.di_pad[0]), 0,
sizeof(dip->di_core.di_pad));
ASSERT(ip->i_d.di_projid == 0);
}
#define mraccess(a) ((void) 0)
#define ismrlocked(a,b) 1
#define spinlock_init(a,b) ((void) 0)
-#define ovbcopy(from,to,count) memmove(to,from,count)
#define __return_address __builtin_return_address(0)
#define xfs_btree_reada_bufl(m,fsb,c) ((void) 0)
#define xfs_btree_reada_bufs(m,fsb,c,x) ((void) 0)
}
#endif
if (ptr < INT_GET(block->bb_numrecs, ARCH_CONVERT)) {
- ovbcopy(&lkp[ptr], &lkp[ptr - 1],
+ memmove(&lkp[ptr - 1], &lkp[ptr],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr) * sizeof(*lkp)); /* INT_: mem copy */
- ovbcopy(&lpp[ptr], &lpp[ptr - 1],
+ memmove(&lpp[ptr - 1], &lpp[ptr],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr) * sizeof(*lpp)); /* INT_: mem copy */
xfs_alloc_log_ptrs(cur, bp, ptr, INT_GET(block->bb_numrecs, ARCH_CONVERT) - 1);
xfs_alloc_log_keys(cur, bp, ptr, INT_GET(block->bb_numrecs, ARCH_CONVERT) - 1);
else {
lrp = XFS_ALLOC_REC_ADDR(block, 1, cur);
if (ptr < INT_GET(block->bb_numrecs, ARCH_CONVERT)) {
- ovbcopy(&lrp[ptr], &lrp[ptr - 1],
+ memmove(&lrp[ptr - 1], &lrp[ptr],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr) * sizeof(*lrp));
xfs_alloc_log_recs(cur, bp, ptr, INT_GET(block->bb_numrecs, ARCH_CONVERT) - 1);
}
return error;
}
#endif
- bcopy(rkp, lkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*lkp)); /* INT_: structure copy */
- bcopy(rpp, lpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*lpp)); /* INT_: structure copy */
+ memcpy(lkp, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*lkp)); /* INT_: structure copy */
+ memcpy(lpp, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*lpp)); /* INT_: structure copy */
xfs_alloc_log_keys(cur, lbp, INT_GET(left->bb_numrecs, ARCH_CONVERT) + 1,
INT_GET(left->bb_numrecs, ARCH_CONVERT) + INT_GET(right->bb_numrecs, ARCH_CONVERT));
xfs_alloc_log_ptrs(cur, lbp, INT_GET(left->bb_numrecs, ARCH_CONVERT) + 1,
*/
lrp = XFS_ALLOC_REC_ADDR(left, INT_GET(left->bb_numrecs, ARCH_CONVERT) + 1, cur);
rrp = XFS_ALLOC_REC_ADDR(right, 1, cur);
- bcopy(rrp, lrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*lrp));
+ memcpy(lrp, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*lrp));
xfs_alloc_log_recs(cur, lbp, INT_GET(left->bb_numrecs, ARCH_CONVERT) + 1,
INT_GET(left->bb_numrecs, ARCH_CONVERT) + INT_GET(right->bb_numrecs, ARCH_CONVERT));
}
return error;
}
#endif
- ovbcopy(&kp[ptr - 1], &kp[ptr],
+ memmove(&kp[ptr], &kp[ptr - 1],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr + 1) * sizeof(*kp)); /* INT_: copy */
- ovbcopy(&pp[ptr - 1], &pp[ptr],
+ memmove(&pp[ptr], &pp[ptr - 1],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr + 1) * sizeof(*pp)); /* INT_: copy */
#ifdef DEBUG
if ((error = xfs_btree_check_sptr(cur, *bnop, level)))
* It's a leaf entry. Make a hole for the new record.
*/
rp = XFS_ALLOC_REC_ADDR(block, 1, cur);
- ovbcopy(&rp[ptr - 1], &rp[ptr],
+ memmove(&rp[ptr], &rp[ptr - 1],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr + 1) * sizeof(*rp));
/*
* Now stuff the new record in, bump numrecs
return error;
}
#endif
- ovbcopy(rkp + 1, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- ovbcopy(rpp + 1, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memmove(rkp, rkp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memmove(rpp, rpp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
xfs_alloc_log_keys(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
xfs_alloc_log_ptrs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
} else {
- ovbcopy(rrp + 1, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memmove(rrp, rrp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
xfs_alloc_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
key.ar_startblock = rrp->ar_startblock; /* INT_: direct copy */
key.ar_blockcount = rrp->ar_blockcount; /* INT_: direct copy */
return error;
}
#endif
- ovbcopy(rkp, rkp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- ovbcopy(rpp, rpp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memmove(rkp + 1, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memmove(rpp + 1, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
#ifdef DEBUG
if ((error = xfs_btree_check_sptr(cur, INT_GET(*lpp, ARCH_CONVERT), level)))
return error;
lrp = XFS_ALLOC_REC_ADDR(left, INT_GET(left->bb_numrecs, ARCH_CONVERT), cur);
rrp = XFS_ALLOC_REC_ADDR(right, 1, cur);
- ovbcopy(rrp, rrp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memmove(rrp + 1, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
*rrp = *lrp;
xfs_alloc_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) + 1);
key.ar_startblock = rrp->ar_startblock; /* INT_: direct copy */
return error;
}
#endif
- bcopy(lkp, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp)); /* INT_: copy */
- bcopy(lpp, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));/* INT_: copy */
+ memcpy(rkp, lkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp)); /* INT_: copy */
+ memcpy(rpp, lpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp)); /* INT_: copy */
xfs_alloc_log_keys(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
xfs_alloc_log_ptrs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
*keyp = *rkp;
lrp = XFS_ALLOC_REC_ADDR(left, i, cur);
rrp = XFS_ALLOC_REC_ADDR(right, 1, cur);
- bcopy(lrp, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memcpy(rrp, lrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
xfs_alloc_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
keyp->ar_startblock = rrp->ar_startblock; /* INT_: direct copy */
keyp->ar_blockcount = rrp->ar_blockcount; /* INT_: direct copy */
return(error);
ASSERT(bp != NULL);
leaf = bp->data;
- bzero((char *)leaf, XFS_LBSIZE(dp->i_mount));
+ memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
hdr = &leaf->hdr;
INT_SET(hdr->info.magic, ARCH_CONVERT, XFS_ATTR_LEAF_MAGIC);
INT_SET(hdr->firstused, ARCH_CONVERT, XFS_LBSIZE(dp->i_mount));
if (args->index < INT_GET(hdr->count, ARCH_CONVERT)) {
tmp = INT_GET(hdr->count, ARCH_CONVERT) - args->index;
tmp *= sizeof(xfs_attr_leaf_entry_t);
- ovbcopy((char *)entry, (char *)(entry+1), tmp);
+ memmove((char *)(entry+1), (char *)entry, tmp);
xfs_da_log_buf(args->trans, bp,
XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
}
name_loc = XFS_ATTR_LEAF_NAME_LOCAL(leaf, args->index);
name_loc->namelen = args->namelen;
INT_SET(name_loc->valuelen, ARCH_CONVERT, args->valuelen);
- bcopy(args->name, (char *)name_loc->nameval, args->namelen);
- bcopy(args->value, (char *)&name_loc->nameval[args->namelen],
+ memcpy((char *)name_loc->nameval, args->name, args->namelen);
+ memcpy((char *)&name_loc->nameval[args->namelen], args->value,
INT_GET(name_loc->valuelen, ARCH_CONVERT));
} else {
name_rmt = XFS_ATTR_LEAF_NAME_REMOTE(leaf, args->index);
name_rmt->namelen = args->namelen;
- bcopy(args->name, (char *)name_rmt->name, args->namelen);
+ memcpy((char *)name_rmt->name, args->name, args->namelen);
entry->flags |= XFS_ATTR_INCOMPLETE;
/* just in case */
INT_ZERO(name_rmt->valuelen, ARCH_CONVERT);
mp = trans->t_mountp;
tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
ASSERT(tmpbuffer != NULL);
- bcopy(bp->data, tmpbuffer, XFS_LBSIZE(mp));
- bzero(bp->data, XFS_LBSIZE(mp));
+ memcpy(tmpbuffer, bp->data, XFS_LBSIZE(mp));
+ memset(bp->data, 0, XFS_LBSIZE(mp));
/*
* Copy basic information
* path point to the block we want to drop (this one).
*/
forward = (!INT_ISZERO(info->forw, ARCH_CONVERT));
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
error = xfs_da_path_shift(state, &state->altpath, forward,
0, &retval);
if (error)
* Make altpath point to the block we want to keep (the lower
* numbered block) and path point to the block we want to drop.
*/
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
if (blkno < blk->blkno) {
error = xfs_da_path_shift(state, &state->altpath, forward,
0, &retval);
*/
tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
ASSERT(tmpbuffer != NULL);
- bzero(tmpbuffer, state->blocksize);
+ memset(tmpbuffer, 0, state->blocksize);
tmp_leaf = (xfs_attr_leafblock_t *)tmpbuffer;
tmp_hdr = &tmp_leaf->hdr;
tmp_hdr->info = save_hdr->info; /* struct copy */
(int)INT_GET(drop_hdr->count, ARCH_CONVERT),
mp);
}
- bcopy((char *)tmp_leaf, (char *)save_leaf, state->blocksize);
+ memcpy((char *)save_leaf, (char *)tmp_leaf, state->blocksize);
kmem_free(tmpbuffer, state->blocksize);
}
tmp *= sizeof(xfs_attr_leaf_entry_t);
entry_s = &leaf_d->entries[start_d];
entry_d = &leaf_d->entries[start_d + count];
- ovbcopy((char *)entry_s, (char *)entry_d, tmp);
+ memmove((char *)entry_d, (char *)entry_s, tmp);
}
/*
* off for 6.2, should be revisited later.
*/
if (entry_s->flags & XFS_ATTR_INCOMPLETE) { /* skip partials? */
- bzero(XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), tmp);
+ memset(XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), 0, tmp);
INT_MOD(hdr_s->usedbytes, ARCH_CONVERT, -tmp);
INT_MOD(hdr_s->count, ARCH_CONVERT, -1);
entry_d--; /* to compensate for ++ in loop hdr */
entry_d->flags = entry_s->flags;
ASSERT(INT_GET(entry_d->nameidx, ARCH_CONVERT) + tmp
<= XFS_LBSIZE(mp));
- ovbcopy(XFS_ATTR_LEAF_NAME(leaf_s, start_s + i),
- XFS_ATTR_LEAF_NAME(leaf_d, desti), tmp);
+ memmove(XFS_ATTR_LEAF_NAME(leaf_d, desti),
+ XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), tmp);
ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT) + tmp
<= XFS_LBSIZE(mp));
- bzero(XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), tmp);
+ memset(XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), 0, tmp);
INT_MOD(hdr_s->usedbytes, ARCH_CONVERT, -tmp);
INT_MOD(hdr_d->usedbytes, ARCH_CONVERT, tmp);
INT_MOD(hdr_s->count, ARCH_CONVERT, -1);
entry_s = &leaf_s->entries[start_s];
ASSERT(((char *)entry_s + tmp) <=
((char *)leaf_s + XFS_LBSIZE(mp)));
- bzero((char *)entry_s, tmp);
+ memset((char *)entry_s, 0, tmp);
} else {
/*
* Move the remaining entries down to fill the hole,
tmp *= sizeof(xfs_attr_leaf_entry_t);
entry_s = &leaf_s->entries[start_s + count];
entry_d = &leaf_s->entries[start_s];
- ovbcopy((char *)entry_s, (char *)entry_d, tmp);
+ memmove((char *)entry_d, (char *)entry_s, tmp);
tmp = count * sizeof(xfs_attr_leaf_entry_t);
entry_s = &leaf_s->entries[INT_GET(hdr_s->count,
ARCH_CONVERT)];
ASSERT(((char *)entry_s + tmp) <=
((char *)leaf_s + XFS_LBSIZE(mp)));
- bzero((char *)entry_s, tmp);
+ memset((char *)entry_s, 0, tmp);
}
/*
ASSERT(ifp->if_flags & XFS_IFEXTENTS);
base = ifp->if_u1.if_extents;
nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t) - count;
- ovbcopy(&base[idx + count], &base[idx],
+ memmove(&base[idx], &base[idx + count],
(nextents - idx) * sizeof(*base));
xfs_iext_realloc(ip, -count, whichfork);
}
xfs_iext_realloc(ip, count, whichfork);
base = ifp->if_u1.if_extents;
nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
- ovbcopy(&base[idx], &base[idx + count],
+ memmove(&base[idx + count], &base[idx],
(nextents - (idx + count)) * sizeof(*base));
for (to = idx; to < idx + count; to++, new++)
xfs_bmbt_set_all(&base[to], new);
ASSERT(args.len == 1);
*firstblock = args.fsbno;
bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0);
- bcopy(ifp->if_u1.if_data, (char *)XFS_BUF_PTR(bp),
+ memcpy((char *)XFS_BUF_PTR(bp), ifp->if_u1.if_data,
ifp->if_bytes);
xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1);
xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
break;
pp = XFS_BTREE_PTR_ADDR(mp->m_sb.sb_blocksize, xfs_bmbt, block,
1, mp->m_bmap_dmxr[1]);
-#ifndef __KERNEL__
XFS_WANT_CORRUPTED_GOTO(
XFS_FSB_SANITY_CHECK(mp, INT_GET(*pp, ARCH_CONVERT)),
error0);
-#else /* additional, temporary, debugging code */
- if (!(XFS_FSB_SANITY_CHECK(mp, INT_GET(*pp, ARCH_CONVERT)))) {
- cmn_err(CE_NOTE,
- "xfs_bmap_read_extents: FSB Sanity Check:");
- if (!(XFS_FSB_TO_AGNO(mp, INT_GET(*pp, ARCH_CONVERT)) < mp->m_sb.sb_agcount))
- cmn_err(CE_NOTE,
- "bad AG count %d < agcount %d",
- XFS_FSB_TO_AGNO(mp, INT_GET(*pp, ARCH_CONVERT)),
- mp->m_sb.sb_agcount);
- if (!(XFS_FSB_TO_AGBNO(mp, INT_GET(*pp, ARCH_CONVERT)) < mp->m_sb.sb_agblocks))
- cmn_err(CE_NOTE,
- "bad AG BNO %d < %d",
- XFS_FSB_TO_AGBNO(mp, INT_GET(*pp, ARCH_CONVERT)),
- mp->m_sb.sb_agblocks);
- error = XFS_ERROR(EFSCORRUPTED);
- goto error0;
- }
-#endif
bno = INT_GET(*pp, ARCH_CONVERT);
xfs_trans_brelse(tp, bp);
}
(unsigned long long) ip->i_ino);
goto error0;
}
-#ifndef __KERNEL__
XFS_WANT_CORRUPTED_GOTO(
XFS_BMAP_SANITY_CHECK(mp, block, 0),
error0);
-#else /* additional, temporary, debugging code */
- if (!(XFS_BMAP_SANITY_CHECK(mp, block, 0))) {
- cmn_err(CE_NOTE,
- "xfs_bmap_read_extents: BMAP Sanity Check:");
- if (!(INT_GET(block->bb_magic, ARCH_CONVERT) == XFS_BMAP_MAGIC))
- cmn_err(CE_NOTE,
- "bb_magic 0x%x",
- INT_GET(block->bb_magic, ARCH_CONVERT));
- if (!(INT_GET(block->bb_level, ARCH_CONVERT) == level))
- cmn_err(CE_NOTE,
- "bb_level %d",
- INT_GET(block->bb_level, ARCH_CONVERT));
- if (!(INT_GET(block->bb_numrecs, ARCH_CONVERT) > 0))
- cmn_err(CE_NOTE,
- "bb_numrecs %d",
- INT_GET(block->bb_numrecs, ARCH_CONVERT));
- if (!(INT_GET(block->bb_numrecs, ARCH_CONVERT) <= (mp)->m_bmap_dmxr[(level) != 0]))
- cmn_err(CE_NOTE,
- "bb_numrecs %d < m_bmap_dmxr[] %d",
- INT_GET(block->bb_numrecs, ARCH_CONVERT),
- (mp)->m_bmap_dmxr[(level) != 0]);
- error = XFS_ERROR(EFSCORRUPTED);
- goto error0;
- }
-#endif
/*
* Read-ahead the next leaf block, if any.
*/
*/
frp = XFS_BTREE_REC_ADDR(mp->m_sb.sb_blocksize, xfs_bmbt,
block, 1, mp->m_bmap_dmxr[0]);
- bcopy(frp, trp, num_recs * sizeof(*frp));
+ memcpy(trp, frp, num_recs * sizeof(*frp));
if (exntf == XFS_EXTFMT_NOSTATE) {
/*
* Check all attribute bmap btree records and
if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL) {
-#ifdef __KERNEL__ /* additional, temporary, debugging code */
- cmn_err(CE_NOTE,
- "EFSCORRUPTED returned from file %s line %d",
- __FILE__, __LINE__);
-#endif
return XFS_ERROR(EFSCORRUPTED);
}
mp = ip->i_mount;
ifp = XFS_IFORK_PTR(ip, whichfork);
if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) {
-#ifdef __KERNEL__ /* additional, temporary, debugging code */
- cmn_err(CE_NOTE,
- "EFSCORRUPTED returned from file %s line %d",
- __FILE__, __LINE__);
-#endif
return XFS_ERROR(EFSCORRUPTED);
}
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
ifp = XFS_IFORK_PTR(ip, whichfork);
if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) {
-#ifdef __KERNEL__ /* additional, temporary, debugging code */
- cmn_err(CE_NOTE,
- "EFSCORRUPTED returned from file %s line %d",
- __FILE__, __LINE__);
-#endif
return XFS_ERROR(EFSCORRUPTED);
}
mp = ip->i_mount;
}
#endif
if (ptr < numrecs) {
- ovbcopy(&kp[ptr], &kp[ptr - 1],
+ memmove(&kp[ptr - 1], &kp[ptr],
(numrecs - ptr) * sizeof(*kp));
- ovbcopy(&pp[ptr], &pp[ptr - 1], /* INT_: direct copy */
+ memmove(&pp[ptr - 1], &pp[ptr], /* INT_: direct copy */
(numrecs - ptr) * sizeof(*pp));
xfs_bmbt_log_ptrs(cur, bp, ptr, numrecs - 1);
xfs_bmbt_log_keys(cur, bp, ptr, numrecs - 1);
} else {
rp = XFS_BMAP_REC_IADDR(block, 1, cur);
if (ptr < numrecs) {
- ovbcopy(&rp[ptr], &rp[ptr - 1],
+ memmove(&rp[ptr - 1], &rp[ptr],
(numrecs - ptr) * sizeof(*rp));
xfs_bmbt_log_recs(cur, bp, ptr, numrecs - 1);
}
}
}
#endif
- bcopy(rkp, lkp, numrrecs * sizeof(*lkp));
- bcopy(rpp, lpp, numrrecs * sizeof(*lpp));
+ memcpy(lkp, rkp, numrrecs * sizeof(*lkp));
+ memcpy(lpp, rpp, numrrecs * sizeof(*lpp));
xfs_bmbt_log_keys(cur, lbp, numlrecs + 1, numlrecs + numrrecs);
xfs_bmbt_log_ptrs(cur, lbp, numlrecs + 1, numlrecs + numrrecs);
} else {
lrp = XFS_BMAP_REC_IADDR(left, numlrecs + 1, cur);
rrp = XFS_BMAP_REC_IADDR(right, 1, cur);
- bcopy(rrp, lrp, numrrecs * sizeof(*lrp));
+ memcpy(lrp, rrp, numrrecs * sizeof(*lrp));
xfs_bmbt_log_recs(cur, lbp, numlrecs + 1, numlrecs + numrrecs);
}
INT_MOD(left->bb_numrecs, ARCH_CONVERT, numrrecs);
}
}
#endif
- ovbcopy(&kp[ptr - 1], &kp[ptr],
+ memmove(&kp[ptr], &kp[ptr - 1],
(numrecs - ptr + 1) * sizeof(*kp));
- ovbcopy(&pp[ptr - 1], &pp[ptr], /* INT_: direct copy */
+ memmove(&pp[ptr], &pp[ptr - 1], /* INT_: direct copy */
(numrecs - ptr + 1) * sizeof(*pp));
#ifdef DEBUG
if ((error = xfs_btree_check_lptr(cur, (xfs_bmbt_ptr_t)*bnop,
xfs_bmbt_log_ptrs(cur, bp, ptr, numrecs);
} else {
rp = XFS_BMAP_REC_IADDR(block, 1, cur);
- ovbcopy(&rp[ptr - 1], &rp[ptr],
+ memmove(&rp[ptr], &rp[ptr - 1],
(numrecs - ptr + 1) * sizeof(*rp));
rp[ptr - 1] = *recp;
numrecs++;
ASSERT(INT_GET(block->bb_numrecs, ARCH_CONVERT) == INT_GET(cblock->bb_numrecs, ARCH_CONVERT));
kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
ckp = XFS_BMAP_KEY_IADDR(cblock, 1, cur);
- bcopy(ckp, kp, INT_GET(block->bb_numrecs, ARCH_CONVERT) * sizeof(*kp));
+ memcpy(kp, ckp, INT_GET(block->bb_numrecs, ARCH_CONVERT) * sizeof(*kp));
pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
cpp = XFS_BMAP_PTR_IADDR(cblock, 1, cur);
#ifdef DEBUG
}
}
#endif
- bcopy(cpp, pp, INT_GET(block->bb_numrecs, ARCH_CONVERT) * sizeof(*pp));
+ memcpy(pp, cpp, INT_GET(block->bb_numrecs, ARCH_CONVERT) * sizeof(*pp));
xfs_bmap_add_free(XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(cbp)), 1,
cur->bc_private.b.flist, cur->bc_mp);
if (!async)
}
}
#endif
- ovbcopy(rkp + 1, rkp, rrecs * sizeof(*rkp));
- ovbcopy(rpp + 1, rpp, rrecs * sizeof(*rpp));
+ memmove(rkp, rkp + 1, rrecs * sizeof(*rkp));
+ memmove(rpp, rpp + 1, rrecs * sizeof(*rpp));
xfs_bmbt_log_keys(cur, rbp, 1, rrecs);
xfs_bmbt_log_ptrs(cur, rbp, 1, rrecs);
} else {
- ovbcopy(rrp + 1, rrp, rrecs * sizeof(*rrp));
+ memmove(rrp, rrp + 1, rrecs * sizeof(*rrp));
xfs_bmbt_log_recs(cur, rbp, 1, rrecs);
INT_SET(key.br_startoff, ARCH_CONVERT, xfs_bmbt_get_startoff(rrp));
rkp = &key;
}
}
#endif
- ovbcopy(rkp, rkp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- ovbcopy(rpp, rpp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memmove(rkp + 1, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memmove(rpp + 1, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
#ifdef DEBUG
if ((error = xfs_btree_check_lptr(cur, INT_GET(*lpp, ARCH_CONVERT), level))) {
XFS_BMBT_TRACE_CURSOR(cur, ERROR);
} else {
lrp = XFS_BMAP_REC_IADDR(left, INT_GET(left->bb_numrecs, ARCH_CONVERT), cur);
rrp = XFS_BMAP_REC_IADDR(right, 1, cur);
- ovbcopy(rrp, rrp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memmove(rrp + 1, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
*rrp = *lrp;
xfs_bmbt_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) + 1);
INT_SET(key.br_startoff, ARCH_CONVERT, xfs_bmbt_get_startoff(rrp));
}
}
#endif
- bcopy(lkp, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- bcopy(lpp, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memcpy(rkp, lkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memcpy(rpp, lpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
xfs_bmbt_log_keys(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
xfs_bmbt_log_ptrs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
keyp->br_startoff = INT_GET(rkp->br_startoff, ARCH_CONVERT);
} else {
lrp = XFS_BMAP_REC_IADDR(left, i, cur);
rrp = XFS_BMAP_REC_IADDR(right, 1, cur);
- bcopy(lrp, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memcpy(rrp, lrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
xfs_bmbt_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
keyp->br_startoff = xfs_bmbt_get_startoff(rrp);
}
fpp = XFS_BTREE_PTR_ADDR(dblocklen, xfs_bmdr, dblock, 1, dmxr);
tpp = XFS_BMAP_BROOT_PTR_ADDR(rblock, 1, rblocklen);
dmxr = INT_GET(dblock->bb_numrecs, ARCH_CONVERT);
- bcopy(fkp, tkp, sizeof(*fkp) * dmxr);
- bcopy(fpp, tpp, sizeof(*fpp) * dmxr); /* INT_: direct copy */
+ memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
+ memcpy(tpp, fpp, sizeof(*fpp) * dmxr); /* INT_: direct copy */
}
/*
cur->bc_ptrs[level + 1] = 1;
kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
ckp = XFS_BMAP_KEY_IADDR(cblock, 1, cur);
- bcopy(kp, ckp, INT_GET(cblock->bb_numrecs, ARCH_CONVERT) * sizeof(*kp));
+ memcpy(ckp, kp, INT_GET(cblock->bb_numrecs, ARCH_CONVERT) * sizeof(*kp));
cpp = XFS_BMAP_PTR_IADDR(cblock, 1, cur);
#ifdef DEBUG
for (i = 0; i < INT_GET(cblock->bb_numrecs, ARCH_CONVERT); i++) {
}
}
#endif
- bcopy(pp, cpp, INT_GET(cblock->bb_numrecs, ARCH_CONVERT) * sizeof(*pp));
+ memcpy(cpp, pp, INT_GET(cblock->bb_numrecs, ARCH_CONVERT) * sizeof(*pp));
#ifdef DEBUG
if ((error = xfs_btree_check_lptr(cur, (xfs_bmbt_ptr_t)args.fsbno,
level))) {
fpp = XFS_BMAP_BROOT_PTR_ADDR(rblock, 1, rblocklen);
tpp = XFS_BTREE_PTR_ADDR(dblocklen, xfs_bmdr, dblock, 1, dmxr);
dmxr = INT_GET(dblock->bb_numrecs, ARCH_CONVERT);
- bcopy(fkp, tkp, sizeof(*fkp) * dmxr);
- bcopy(fpp, tpp, sizeof(*fpp) * dmxr); /* INT_: direct copy */
+ memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
+ memcpy(tpp, fpp, sizeof(*fpp) * dmxr); /* INT_: direct copy */
}
/*
size = (int)((char *)&leaf->ents[INT_GET(leaf->hdr.count, ARCH_CONVERT)] -
(char *)leaf);
}
- bcopy(oldroot, node, size);
+ memcpy(node, oldroot, size);
xfs_da_log_buf(tp, bp, 0, size - 1);
xfs_da_buf_done(blk1->bp);
blk1->bp = bp;
tmp *= (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node2->btree[0];
btree_d = &node2->btree[count];
- ovbcopy(btree_s, btree_d, tmp);
+ memmove(btree_d, btree_s, tmp);
}
/*
tmp = count * (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node1->btree[INT_GET(node1->hdr.count, ARCH_CONVERT) - count];
btree_d = &node2->btree[0];
- bcopy(btree_s, btree_d, tmp);
+ memcpy(btree_d, btree_s, tmp);
INT_MOD(node1->hdr.count, ARCH_CONVERT, -(count));
} else {
tmp = count * (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node2->btree[0];
btree_d = &node1->btree[INT_GET(node1->hdr.count, ARCH_CONVERT)];
- bcopy(btree_s, btree_d, tmp);
+ memcpy(btree_d, btree_s, tmp);
INT_MOD(node1->hdr.count, ARCH_CONVERT, count);
xfs_da_log_buf(tp, blk1->bp,
XFS_DA_LOGRANGE(node1, btree_d, tmp));
tmp *= (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node2->btree[count];
btree_d = &node2->btree[0];
- ovbcopy(btree_s, btree_d, tmp);
+ memmove(btree_d, btree_s, tmp);
INT_MOD(node2->hdr.count, ARCH_CONVERT, -(count));
}
btree = &node->btree[ oldblk->index ];
if (oldblk->index < INT_GET(node->hdr.count, ARCH_CONVERT)) {
tmp = (INT_GET(node->hdr.count, ARCH_CONVERT) - oldblk->index) * (uint)sizeof(*btree);
- ovbcopy(btree, btree + 1, tmp);
+ memmove(btree + 1, btree, tmp);
}
INT_SET(btree->hashval, ARCH_CONVERT, newblk->hashval);
INT_SET(btree->before, ARCH_CONVERT, newblk->blkno);
}
ASSERT(INT_ISZERO(blkinfo->forw, ARCH_CONVERT));
ASSERT(INT_ISZERO(blkinfo->back, ARCH_CONVERT));
- bcopy(bp->data, root_blk->bp->data, state->blocksize);
+ memcpy(root_blk->bp->data, bp->data, state->blocksize);
xfs_da_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
error = xfs_da_shrink_inode(args, child, bp);
return(error);
* path point to the block we want to drop (this one).
*/
forward = (!INT_ISZERO(info->forw, ARCH_CONVERT));
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
error = xfs_da_path_shift(state, &state->altpath, forward,
0, &retval);
if (error)
* Make altpath point to the block we want to keep (the lower
* numbered block) and path point to the block we want to drop.
*/
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
if (blkno < blk->blkno) {
error = xfs_da_path_shift(state, &state->altpath, forward,
0, &retval);
if (drop_blk->index < (INT_GET(node->hdr.count, ARCH_CONVERT)-1)) {
tmp = INT_GET(node->hdr.count, ARCH_CONVERT) - drop_blk->index - 1;
tmp *= (uint)sizeof(xfs_da_node_entry_t);
- ovbcopy(btree + 1, btree, tmp);
+ memmove(btree, btree + 1, tmp);
xfs_da_log_buf(state->args->trans, drop_blk->bp,
XFS_DA_LOGRANGE(node, btree, tmp));
btree = &node->btree[ INT_GET(node->hdr.count, ARCH_CONVERT)-1 ];
}
- bzero((char *)btree, sizeof(xfs_da_node_entry_t));
+ memset((char *)btree, 0, sizeof(xfs_da_node_entry_t));
xfs_da_log_buf(state->args->trans, drop_blk->bp,
XFS_DA_LOGRANGE(node, btree, sizeof(*btree)));
INT_MOD(node->hdr.count, ARCH_CONVERT, -1);
{
btree = &save_node->btree[ INT_GET(drop_node->hdr.count, ARCH_CONVERT) ];
tmp = INT_GET(save_node->hdr.count, ARCH_CONVERT) * (uint)sizeof(xfs_da_node_entry_t);
- ovbcopy(&save_node->btree[0], btree, tmp);
+ memmove(btree, &save_node->btree[0], tmp);
btree = &save_node->btree[0];
xfs_da_log_buf(tp, save_blk->bp,
XFS_DA_LOGRANGE(save_node, btree,
* Move all the B-tree elements from drop_blk to save_blk.
*/
tmp = INT_GET(drop_node->hdr.count, ARCH_CONVERT) * (uint)sizeof(xfs_da_node_entry_t);
- bcopy(&drop_node->btree[0], btree, tmp);
+ memcpy(btree, &drop_node->btree[0], tmp);
INT_MOD(save_node->hdr.count, ARCH_CONVERT, INT_GET(drop_node->hdr.count, ARCH_CONVERT));
xfs_da_log_buf(tp, save_blk->bp,
/*
* Copy the last block into the dead buffer and log it.
*/
- bcopy(last_buf->data, dead_buf->data, mp->m_dirblksize);
+ memcpy(dead_buf->data, last_buf->data, mp->m_dirblksize);
xfs_da_log_buf(tp, dead_buf, 0, mp->m_dirblksize - 1);
dead_info = dead_buf->data;
/*
if (state->extravalid && state->extrablk.bp)
xfs_da_buf_done(state->extrablk.bp);
#ifdef DEBUG
- bzero((char *)state, sizeof(*state));
+ memset((char *)state, 0, sizeof(*state));
#endif /* DEBUG */
kmem_zone_free(xfs_da_state_zone, state);
}
dabuf->data = kmem_alloc(BBTOB(dabuf->bbcount), KM_SLEEP);
for (i = off = 0; i < nbuf; i++, off += XFS_BUF_COUNT(bp)) {
bp = bps[i];
- bcopy(XFS_BUF_PTR(bp), (char *)dabuf->data + off,
+ memcpy((char *)dabuf->data + off, XFS_BUF_PTR(bp),
XFS_BUF_COUNT(bp));
}
}
for (i = off = 0; i < dabuf->nbuf;
i++, off += XFS_BUF_COUNT(bp)) {
bp = dabuf->bps[i];
- bcopy((char *)dabuf->data + off, XFS_BUF_PTR(bp),
+ memcpy(XFS_BUF_PTR(bp), (char *)dabuf->data + off,
XFS_BUF_COUNT(bp));
}
}
dabuf->next->prev = dabuf->prev;
mutex_spinunlock(&xfs_dabuf_global_lock, s);
}
- bzero(dabuf, XFS_DA_BUF_SIZE(dabuf->nbuf));
+ memset(dabuf, 0, XFS_DA_BUF_SIZE(dabuf->nbuf));
#endif
if (dabuf->nbuf == 1)
kmem_zone_free(xfs_dabuf_zone, dabuf);
bp = dabuf->bps[0];
} else {
bplist = kmem_alloc(nbuf * sizeof(*bplist), KM_SLEEP);
- bcopy(dabuf->bps, bplist, nbuf * sizeof(*bplist));
+ memcpy(bplist, dabuf->bps, nbuf * sizeof(*bplist));
}
xfs_da_buf_done(dabuf);
for (i = 0; i < nbuf; i++)
bp = dabuf->bps[0];
} else {
bplist = kmem_alloc(nbuf * sizeof(*bplist), KM_SLEEP);
- bcopy(dabuf->bps, bplist, nbuf * sizeof(*bplist));
+ memcpy(bplist, dabuf->bps, nbuf * sizeof(*bplist));
}
xfs_da_buf_done(dabuf);
for (i = 0; i < nbuf; i++)
xfs_da_args_t args;
int error;
- bzero((char *)&args, sizeof(args));
+ memset((char *)&args, 0, sizeof(args));
args.dp = dir;
args.trans = trans;
xfs_da_args_t args; /* operation arguments */
int error; /* error return value */
- bzero((char *)&args, sizeof(args));
+ memset((char *)&args, 0, sizeof(args));
args.dp = dp;
args.trans = tp;
ASSERT((dp->i_d.di_mode & IFMT) == IFDIR);
blp--;
mid++;
if (mid)
- ovbcopy(&blp[1], blp, mid * sizeof(*blp));
+ memmove(blp, &blp[1], mid * sizeof(*blp));
lfloglow = 0;
lfloghigh = mid;
}
(highstale == INT_GET(btp->count, ARCH_CONVERT) ||
mid - lowstale <= highstale - mid)) {
if (mid - lowstale)
- ovbcopy(&blp[lowstale + 1], &blp[lowstale],
+ memmove(&blp[lowstale], &blp[lowstale + 1],
(mid - lowstale) * sizeof(*blp));
lfloglow = MIN(lowstale, lfloglow);
lfloghigh = MAX(mid, lfloghigh);
ASSERT(highstale < INT_GET(btp->count, ARCH_CONVERT));
mid++;
if (highstale - mid)
- ovbcopy(&blp[mid], &blp[mid + 1],
+ memmove(&blp[mid + 1], &blp[mid],
(highstale - mid) * sizeof(*blp));
lfloglow = MIN(mid, lfloglow);
lfloghigh = MAX(highstale, lfloghigh);
*/
INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
dep->namelen = args->namelen;
- bcopy(args->name, dep->name, args->namelen);
+ memcpy(dep->name, args->name, args->namelen);
tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)block));
/*
*/
if (dep->namelen == args->namelen &&
dep->name[0] == args->name[0] &&
- bcmp(dep->name, args->name, args->namelen) == 0) {
+ memcmp(dep->name, args->name, args->namelen) == 0) {
*bpp = bp;
*entno = mid;
return 0;
buf_len = dp->i_df.if_bytes;
buf = kmem_alloc(dp->i_df.if_bytes, KM_SLEEP);
- bcopy(sfp, buf, dp->i_df.if_bytes);
+ memcpy(buf, sfp, dp->i_df.if_bytes);
xfs_idata_realloc(dp, -dp->i_df.if_bytes, XFS_DATA_FORK);
dp->i_d.di_size = 0;
xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
INT_SET(dep->inumber, ARCH_CONVERT, XFS_DIR2_SF_GET_INUMBER_ARCH(sfp,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT));
dep->namelen = sfep->namelen;
- bcopy(sfep->name, dep->name, dep->namelen);
+ memcpy(dep->name, sfep->name, dep->namelen);
tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)block));
xfs_dir2_data_log_entry(tp, bp, dep);
/*
* Start by clearing the table.
*/
- bzero(d->hdr.bestfree, sizeof(d->hdr.bestfree));
+ memset(d->hdr.bestfree, 0, sizeof(d->hdr.bestfree));
*loghead = 1;
/*
* Set up pointers.
* Could compact these but I think we always do the conversion
* after squeezing out stale entries.
*/
- bcopy(blp, leaf->ents, INT_GET(btp->count, ARCH_CONVERT) * sizeof(xfs_dir2_leaf_entry_t));
+ memcpy(leaf->ents, blp, INT_GET(btp->count, ARCH_CONVERT) * sizeof(xfs_dir2_leaf_entry_t));
xfs_dir2_leaf_log_ents(tp, lbp, 0, INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1);
needscan = 0;
needlog = 1;
*/
if (use_block >= INT_GET(ltp->bestcount, ARCH_CONVERT)) {
bestsp--;
- ovbcopy(&bestsp[1], &bestsp[0],
+ memmove(&bestsp[0], &bestsp[1],
INT_GET(ltp->bestcount, ARCH_CONVERT) * sizeof(bestsp[0]));
INT_MOD(ltp->bestcount, ARCH_CONVERT, +1);
xfs_dir2_leaf_log_tail(tp, lbp);
dep = (xfs_dir2_data_entry_t *)dup;
INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
dep->namelen = args->namelen;
- bcopy(args->name, dep->name, dep->namelen);
+ memcpy(dep->name, args->name, dep->namelen);
tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)data));
/*
* lep is still good as the index leaf entry.
*/
if (index < INT_GET(leaf->hdr.count, ARCH_CONVERT))
- ovbcopy(lep, lep + 1,
+ memmove(lep + 1, lep,
(INT_GET(leaf->hdr.count, ARCH_CONVERT) - index) * sizeof(*lep));
/*
* Record low and high logging indices for the leaf.
* and make room for the new entry.
*/
if (index - lowstale - 1 > 0)
- ovbcopy(&leaf->ents[lowstale + 1],
- &leaf->ents[lowstale],
+ memmove(&leaf->ents[lowstale],
+ &leaf->ents[lowstale + 1],
(index - lowstale - 1) * sizeof(*lep));
lep = &leaf->ents[index - 1];
lfloglow = MIN(lowstale, lfloglow);
* and make room for the new entry.
*/
if (highstale - index > 0)
- ovbcopy(&leaf->ents[index],
- &leaf->ents[index + 1],
+ memmove(&leaf->ents[index + 1],
+ &leaf->ents[index],
(highstale - index) * sizeof(*lep));
lep = &leaf->ents[index];
lfloglow = MIN(index, lfloglow);
*/
if (dep->namelen == args->namelen &&
dep->name[0] == args->name[0] &&
- bcmp(dep->name, args->name, args->namelen) == 0) {
+ memcmp(dep->name, args->name, args->namelen) == 0) {
*dbpp = dbp;
*indexp = index;
return 0;
* Copy the table down so inactive entries at the
* end are removed.
*/
- ovbcopy(bestsp, &bestsp[db - i],
+ memmove(&bestsp[db - i], bestsp,
(INT_GET(ltp->bestcount, ARCH_CONVERT) - (db - i)) * sizeof(*bestsp));
INT_MOD(ltp->bestcount, ARCH_CONVERT, -(db - i));
xfs_dir2_leaf_log_tail(tp, lbp);
*/
bestsp = XFS_DIR2_LEAF_BESTS_P_ARCH(ltp, ARCH_CONVERT);
INT_MOD(ltp->bestcount, ARCH_CONVERT, -1);
- ovbcopy(&bestsp[0], &bestsp[1], INT_GET(ltp->bestcount, ARCH_CONVERT) * sizeof(*bestsp));
+ memmove(&bestsp[1], &bestsp[0], INT_GET(ltp->bestcount, ARCH_CONVERT) * sizeof(*bestsp));
xfs_dir2_leaf_log_tail(tp, lbp);
xfs_dir2_leaf_log_bests(tp, lbp, 0, INT_GET(ltp->bestcount, ARCH_CONVERT) - 1);
return 0;
/*
* Set up the leaf bests table.
*/
- bcopy(free->bests, XFS_DIR2_LEAF_BESTS_P_ARCH(ltp, ARCH_CONVERT),
+ memcpy(XFS_DIR2_LEAF_BESTS_P_ARCH(ltp, ARCH_CONVERT), free->bests,
INT_GET(ltp->bestcount, ARCH_CONVERT) * sizeof(leaf->bests[0]));
xfs_dir2_leaf_log_bests(tp, lbp, 0, INT_GET(ltp->bestcount, ARCH_CONVERT) - 1);
xfs_dir2_leaf_log_tail(tp, lbp);
if (INT_ISZERO(leaf->hdr.stale, ARCH_CONVERT)) {
lep = &leaf->ents[index];
if (index < INT_GET(leaf->hdr.count, ARCH_CONVERT))
- ovbcopy(lep, lep + 1,
+ memmove(lep + 1, lep,
(INT_GET(leaf->hdr.count, ARCH_CONVERT) - index) * sizeof(*lep));
lfloglow = index;
lfloghigh = INT_GET(leaf->hdr.count, ARCH_CONVERT);
XFS_DIR2_NULL_DATAPTR);
ASSERT(index - lowstale - 1 >= 0);
if (index - lowstale - 1 > 0)
- ovbcopy(&leaf->ents[lowstale + 1],
- &leaf->ents[lowstale],
+ memmove(&leaf->ents[lowstale],
+ &leaf->ents[lowstale + 1],
(index - lowstale - 1) * sizeof(*lep));
lep = &leaf->ents[index - 1];
lfloglow = MIN(lowstale, lfloglow);
XFS_DIR2_NULL_DATAPTR);
ASSERT(highstale - index >= 0);
if (highstale - index > 0)
- ovbcopy(&leaf->ents[index],
- &leaf->ents[index + 1],
+ memmove(&leaf->ents[index + 1],
+ &leaf->ents[index],
(highstale - index) * sizeof(*lep));
lep = &leaf->ents[index];
lfloglow = MIN(index, lfloglow);
*/
if (dep->namelen == args->namelen &&
dep->name[0] == args->name[0] &&
- bcmp(dep->name, args->name, args->namelen) == 0) {
+ memcmp(dep->name, args->name, args->namelen) == 0) {
args->inumber = INT_GET(dep->inumber, ARCH_CONVERT);
*indexp = index;
state->extravalid = 1;
* to hold the new entries.
*/
if (start_d < INT_GET(leaf_d->hdr.count, ARCH_CONVERT)) {
- ovbcopy(&leaf_d->ents[start_d], &leaf_d->ents[start_d + count],
+ memmove(&leaf_d->ents[start_d + count], &leaf_d->ents[start_d],
(INT_GET(leaf_d->hdr.count, ARCH_CONVERT) - start_d) *
sizeof(xfs_dir2_leaf_entry_t));
xfs_dir2_leaf_log_ents(tp, bp_d, start_d + count,
/*
* Copy the leaf entries from source to destination.
*/
- bcopy(&leaf_s->ents[start_s], &leaf_d->ents[start_d],
+ memcpy(&leaf_d->ents[start_d], &leaf_s->ents[start_s],
count * sizeof(xfs_dir2_leaf_entry_t));
xfs_dir2_leaf_log_ents(tp, bp_d, start_d, start_d + count - 1);
/*
* delete the ones we copied by sliding the next ones down.
*/
if (start_s + count < INT_GET(leaf_s->hdr.count, ARCH_CONVERT)) {
- ovbcopy(&leaf_s->ents[start_s + count], &leaf_s->ents[start_s],
+ memmove(&leaf_s->ents[start_s], &leaf_s->ents[start_s + count],
count * sizeof(xfs_dir2_leaf_entry_t));
xfs_dir2_leaf_log_ents(tp, bp_s, start_s, start_s + count - 1);
}
* path point to the block we want to drop (this one).
*/
forward = !INT_ISZERO(info->forw, ARCH_CONVERT);
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
error = xfs_da_path_shift(state, &state->altpath, forward, 0,
&rval);
if (error)
* Make altpath point to the block we want to keep (the lower
* numbered block) and path point to the block we want to drop.
*/
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
if (blkno < blk->blkno)
error = xfs_da_path_shift(state, &state->altpath, forward, 0,
&rval);
dep = (xfs_dir2_data_entry_t *)dup;
INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
dep->namelen = args->namelen;
- bcopy(args->name, dep->name, dep->namelen);
+ memcpy(dep->name, args->name, dep->namelen);
tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)data));
xfs_dir2_data_log_entry(tp, dbp, dep);
* and add local data.
*/
block = kmem_alloc(mp->m_dirblksize, KM_SLEEP);
- bcopy(bp->data, block, mp->m_dirblksize);
+ memcpy(block, bp->data, mp->m_dirblksize);
logflags = XFS_ILOG_CORE;
if ((error = xfs_dir2_shrink_inode(args, mp->m_dirdatablk, bp))) {
ASSERT(error != ENOSPC);
* Copy the header into the newly allocate local space.
*/
sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
- bcopy(sfhp, sfp, XFS_DIR2_SF_HDR_SIZE(sfhp->i8count));
+ memcpy(sfp, sfhp, XFS_DIR2_SF_HDR_SIZE(sfhp->i8count));
dp->i_d.di_size = size;
/*
* Set up to loop over the block's entries.
XFS_DIR2_SF_PUT_OFFSET_ARCH(sfep,
(xfs_dir2_data_aoff_t)
((char *)dep - (char *)block), ARCH_CONVERT);
- bcopy(dep->name, sfep->name, dep->namelen);
+ memcpy(sfep->name, dep->name, dep->namelen);
temp=INT_GET(dep->inumber, ARCH_CONVERT);
XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, &temp,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
*/
sfep->namelen = args->namelen;
XFS_DIR2_SF_PUT_OFFSET_ARCH(sfep, offset, ARCH_CONVERT);
- bcopy(args->name, sfep->name, sfep->namelen);
+ memcpy(sfep->name, args->name, sfep->namelen);
XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, &args->inumber,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
/*
old_isize = (int)dp->i_d.di_size;
buf = kmem_alloc(old_isize, KM_SLEEP);
oldsfp = (xfs_dir2_sf_t *)buf;
- bcopy(sfp, oldsfp, old_isize);
+ memcpy(oldsfp, sfp, old_isize);
/*
* Loop over the old directory finding the place we're going
* to insert the new entry.
* Copy the first part of the directory, including the header.
*/
nbytes = (int)((char *)oldsfep - (char *)oldsfp);
- bcopy(oldsfp, sfp, nbytes);
+ memcpy(sfp, oldsfp, nbytes);
sfep = (xfs_dir2_sf_entry_t *)((char *)sfp + nbytes);
/*
* Fill in the new entry, and update the header counts.
*/
sfep->namelen = args->namelen;
XFS_DIR2_SF_PUT_OFFSET_ARCH(sfep, offset, ARCH_CONVERT);
- bcopy(args->name, sfep->name, sfep->namelen);
+ memcpy(sfep->name, args->name, sfep->namelen);
XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, &args->inumber,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
sfp->hdr.count++;
*/
if (!eof) {
sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
- bcopy(oldsfep, sfep, old_isize - nbytes);
+ memcpy(sfep, oldsfep, old_isize - nbytes);
}
kmem_free(buf, old_isize);
dp->i_d.di_size = new_isize;
i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
if (sfep->namelen == args->namelen &&
sfep->name[0] == args->name[0] &&
- bcmp(args->name, sfep->name, args->namelen) == 0) {
+ memcmp(args->name, sfep->name, args->namelen) == 0) {
args->inumber =
XFS_DIR2_SF_GET_INUMBER_ARCH(sfp,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
if (sfep->namelen == args->namelen &&
sfep->name[0] == args->name[0] &&
- bcmp(sfep->name, args->name, args->namelen) == 0) {
+ memcmp(sfep->name, args->name, args->namelen) == 0) {
ASSERT(XFS_DIR2_SF_GET_INUMBER_ARCH(sfp,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT) ==
args->inumber);
* Copy the part if any after the removed entry, sliding it down.
*/
if (byteoff + entsize < oldsize)
- ovbcopy((char *)sfp + byteoff + entsize, (char *)sfp + byteoff,
+ memmove((char *)sfp + byteoff, (char *)sfp + byteoff + entsize,
oldsize - (byteoff + entsize));
/*
* Fix up the header and file size.
i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
if (sfep->namelen == args->namelen &&
sfep->name[0] == args->name[0] &&
- bcmp(args->name, sfep->name, args->namelen) == 0) {
+ memcmp(args->name, sfep->name, args->namelen) == 0) {
#if XFS_BIG_FILESYSTEMS || defined(DEBUG)
ino = XFS_DIR2_SF_GET_INUMBER_ARCH(sfp,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
buf = kmem_alloc(oldsize, KM_SLEEP);
oldsfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
ASSERT(oldsfp->hdr.i8count == 1);
- bcopy(oldsfp, buf, oldsize);
+ memcpy(buf, oldsfp, oldsize);
/*
* Compute the new inode size.
*/
oldsfep = XFS_DIR2_SF_NEXTENTRY(oldsfp, oldsfep)) {
sfep->namelen = oldsfep->namelen;
sfep->offset = oldsfep->offset;
- bcopy(oldsfep->name, sfep->name, sfep->namelen);
+ memcpy(sfep->name, oldsfep->name, sfep->namelen);
ino = XFS_DIR2_SF_GET_INUMBER_ARCH(oldsfp,
XFS_DIR2_SF_INUMBERP(oldsfep), ARCH_CONVERT);
XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, &ino, XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
buf = kmem_alloc(oldsize, KM_SLEEP);
oldsfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
ASSERT(oldsfp->hdr.i8count == 0);
- bcopy(oldsfp, buf, oldsize);
+ memcpy(buf, oldsfp, oldsize);
/*
* Compute the new inode size.
*/
oldsfep = XFS_DIR2_SF_NEXTENTRY(oldsfp, oldsfep)) {
sfep->namelen = oldsfep->namelen;
sfep->offset = oldsfep->offset;
- bcopy(oldsfep->name, sfep->name, sfep->namelen);
+ memcpy(sfep->name, oldsfep->name, sfep->namelen);
ino = XFS_DIR2_SF_GET_INUMBER_ARCH(oldsfp,
XFS_DIR2_SF_INUMBERP(oldsfep), ARCH_CONVERT);
XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, &ino, XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
for (i = INT_GET(sf->hdr.count, ARCH_CONVERT)-1; i >= 0; i--) {
if (sfe->namelen == args->namelen &&
args->name[0] == sfe->name[0] &&
- bcmp(args->name, sfe->name, args->namelen) == 0)
+ memcmp(args->name, sfe->name, args->namelen) == 0)
return(XFS_ERROR(EEXIST));
sfe = XFS_DIR_SF_NEXTENTRY(sfe);
}
XFS_DIR_SF_PUT_DIRINO_ARCH(&args->inumber, &sfe->inumber, ARCH_CONVERT);
sfe->namelen = args->namelen;
- bcopy(args->name, sfe->name, sfe->namelen);
+ memcpy(sfe->name, args->name, sfe->namelen);
INT_MOD(sf->hdr.count, ARCH_CONVERT, +1);
dp->i_d.di_size += size;
size = XFS_DIR_SF_ENTSIZE_BYENTRY(sfe);
if (sfe->namelen == args->namelen &&
sfe->name[0] == args->name[0] &&
- bcmp(sfe->name, args->name, args->namelen) == 0)
+ memcmp(sfe->name, args->name, args->namelen) == 0)
break;
base += size;
sfe = XFS_DIR_SF_NEXTENTRY(sfe);
}
if ((base + size) != dp->i_d.di_size) {
- ovbcopy(&((char *)sf)[base+size], &((char *)sf)[base],
+ memmove(&((char *)sf)[base], &((char *)sf)[base+size],
dp->i_d.di_size - (base+size));
}
INT_MOD(sf->hdr.count, ARCH_CONVERT, -1);
for (i = INT_GET(sf->hdr.count, ARCH_CONVERT)-1; i >= 0; i--) {
if (sfe->namelen == args->namelen &&
sfe->name[0] == args->name[0] &&
- bcmp(args->name, sfe->name, args->namelen) == 0) {
+ memcmp(args->name, sfe->name, args->namelen) == 0) {
XFS_DIR_SF_GET_DIRINO_ARCH(&sfe->inumber, &args->inumber, ARCH_CONVERT);
return(XFS_ERROR(EEXIST));
}
tmpbuffer = kmem_alloc(size, KM_SLEEP);
ASSERT(tmpbuffer != NULL);
- bcopy(dp->i_df.if_u1.if_data, tmpbuffer, size);
+ memcpy(tmpbuffer, dp->i_df.if_u1.if_data, size);
sf = (xfs_dir_shortform_t *)tmpbuffer;
XFS_DIR_SF_GET_DIRINO_ARCH(&sf->hdr.parent, &inumber, ARCH_CONVERT);
for (i = INT_GET(sf->hdr.count, ARCH_CONVERT)-1; i >= 0; i--) {
if (sfe->namelen == args->namelen &&
sfe->name[0] == args->name[0] &&
- bcmp(args->name, sfe->name, args->namelen) == 0) {
- ASSERT(bcmp((char *)&args->inumber,
+ memcmp(args->name, sfe->name, args->namelen) == 0) {
+ ASSERT(memcmp((char *)&args->inumber,
(char *)&sfe->inumber, sizeof(xfs_ino_t)));
XFS_DIR_SF_PUT_DIRINO_ARCH(&args->inumber, &sfe->inumber, ARCH_CONVERT);
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA);
if (retval)
return(retval);
ASSERT(bp != NULL);
- bcopy(bp->data, tmpbuffer, XFS_LBSIZE(dp->i_mount));
+ memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));
leaf = (xfs_dir_leafblock_t *)tmpbuffer;
ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR_LEAF_MAGIC);
- bzero(bp->data, XFS_LBSIZE(dp->i_mount));
+ memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));
/*
* Find and special case the parent inode number
return(retval);
}
ASSERT(bp2 != NULL);
- bcopy(bp1->data, bp2->data, XFS_LBSIZE(dp->i_mount));
+ memcpy(bp2->data, bp1->data, XFS_LBSIZE(dp->i_mount));
xfs_da_buf_done(bp1);
xfs_da_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
return(retval);
ASSERT(bp != NULL);
leaf = bp->data;
- bzero((char *)leaf, XFS_LBSIZE(dp->i_mount));
+ memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
hdr = &leaf->hdr;
INT_SET(hdr->info.magic, ARCH_CONVERT, XFS_DIR_LEAF_MAGIC);
INT_SET(hdr->firstused, ARCH_CONVERT, XFS_LBSIZE(dp->i_mount));
if (index < INT_GET(hdr->count, ARCH_CONVERT)) {
tmp = INT_GET(hdr->count, ARCH_CONVERT) - index;
tmp *= (uint)sizeof(xfs_dir_leaf_entry_t);
- ovbcopy(entry, entry + 1, tmp);
+ memmove(entry + 1, entry, tmp);
xfs_da_log_buf(args->trans, bp,
XFS_DA_LOGRANGE(leaf, entry, tmp + (uint)sizeof(*entry)));
}
*/
namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
XFS_DIR_SF_PUT_DIRINO_ARCH(&args->inumber, &namest->inumber, ARCH_CONVERT);
- bcopy(args->name, namest->name, args->namelen);
+ memcpy(namest->name, args->name, args->namelen);
xfs_da_log_buf(args->trans, bp,
XFS_DA_LOGRANGE(leaf, namest, XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry)));
lbsize = XFS_LBSIZE(mp);
tmpbuffer = kmem_alloc(lbsize, KM_SLEEP);
ASSERT(tmpbuffer != NULL);
- bcopy(bp->data, tmpbuffer, lbsize);
+ memcpy(tmpbuffer, bp->data, lbsize);
/*
* Make a second copy in case xfs_dir_leaf_moveents()
*/
if (musthave || justcheck) {
tmpbuffer2 = kmem_alloc(lbsize, KM_SLEEP);
- bcopy(bp->data, tmpbuffer2, lbsize);
+ memcpy(tmpbuffer2, bp->data, lbsize);
}
- bzero(bp->data, lbsize);
+ memset(bp->data, 0, lbsize);
/*
* Copy basic information
if (justcheck || rval == ENOSPC) {
ASSERT(tmpbuffer2);
- bcopy(tmpbuffer2, bp->data, lbsize);
+ memcpy(bp->data, tmpbuffer2, lbsize);
} else {
xfs_da_log_buf(trans, bp, 0, lbsize - 1);
}
* path point to the block we want to drop (this one).
*/
forward = !INT_ISZERO(info->forw, ARCH_CONVERT);
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
error = xfs_da_path_shift(state, &state->altpath, forward,
0, &retval);
if (error)
* Make altpath point to the block we want to keep (the lower
* numbered block) and path point to the block we want to drop.
*/
- bcopy(&state->path, &state->altpath, sizeof(state->path));
+ memcpy(&state->altpath, &state->path, sizeof(state->path));
if (blkno < blk->blkno) {
error = xfs_da_path_shift(state, &state->altpath, forward,
0, &retval);
* Compress the remaining entries and zero out the removed stuff.
*/
namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
- bzero((char *)namest, entsize);
+ memset((char *)namest, 0, entsize);
xfs_da_log_buf(trans, bp, XFS_DA_LOGRANGE(leaf, namest, entsize));
INT_MOD(hdr->namebytes, ARCH_CONVERT, -(entry->namelen));
tmp = (INT_GET(hdr->count, ARCH_CONVERT) - index) * (uint)sizeof(xfs_dir_leaf_entry_t);
- ovbcopy(entry + 1, entry, tmp);
+ memmove(entry, entry + 1, tmp);
INT_MOD(hdr->count, ARCH_CONVERT, -1);
xfs_da_log_buf(trans, bp,
XFS_DA_LOGRANGE(leaf, entry, tmp + (uint)sizeof(*entry)));
entry = &leaf->entries[INT_GET(hdr->count, ARCH_CONVERT)];
- bzero((char *)entry, sizeof(xfs_dir_leaf_entry_t));
+ memset((char *)entry, 0, sizeof(xfs_dir_leaf_entry_t));
/*
* If we removed the first entry, re-find the first used byte
*/
tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
ASSERT(tmpbuffer != NULL);
- bzero(tmpbuffer, state->blocksize);
+ memset(tmpbuffer, 0, state->blocksize);
tmp_leaf = (xfs_dir_leafblock_t *)tmpbuffer;
tmp_hdr = &tmp_leaf->hdr;
tmp_hdr->info = save_hdr->info; /* struct copy */
tmp_leaf, INT_GET(tmp_leaf->hdr.count, ARCH_CONVERT),
(int)INT_GET(drop_hdr->count, ARCH_CONVERT), mp);
}
- bcopy(tmp_leaf, save_leaf, state->blocksize);
+ memcpy(save_leaf, tmp_leaf, state->blocksize);
kmem_free(tmpbuffer, state->blocksize);
}
namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
if (entry->namelen == args->namelen &&
namest->name[0] == args->name[0] &&
- bcmp(args->name, namest->name, args->namelen) == 0) {
+ memcmp(args->name, namest->name, args->namelen) == 0) {
XFS_DIR_SF_GET_DIRINO_ARCH(&namest->inumber, &args->inumber, ARCH_CONVERT);
*index = probe;
return(XFS_ERROR(EEXIST));
tmp *= (uint)sizeof(xfs_dir_leaf_entry_t);
entry_s = &leaf_d->entries[start_d];
entry_d = &leaf_d->entries[start_d + count];
- bcopy(entry_s, entry_d, tmp);
+ memcpy(entry_d, entry_s, tmp);
}
/*
INT_COPY(entry_d->nameidx, hdr_d->firstused, ARCH_CONVERT);
entry_d->namelen = entry_s->namelen;
ASSERT(INT_GET(entry_d->nameidx, ARCH_CONVERT) + tmp <= XFS_LBSIZE(mp));
- bcopy(XFS_DIR_LEAF_NAMESTRUCT(leaf_s, INT_GET(entry_s->nameidx, ARCH_CONVERT)),
- XFS_DIR_LEAF_NAMESTRUCT(leaf_d, INT_GET(entry_d->nameidx, ARCH_CONVERT)), tmp);
+ memcpy(XFS_DIR_LEAF_NAMESTRUCT(leaf_d, INT_GET(entry_d->nameidx, ARCH_CONVERT)),
+ XFS_DIR_LEAF_NAMESTRUCT(leaf_s, INT_GET(entry_s->nameidx, ARCH_CONVERT)), tmp);
ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT) + tmp <= XFS_LBSIZE(mp));
- bzero((char *)XFS_DIR_LEAF_NAMESTRUCT(leaf_s, INT_GET(entry_s->nameidx, ARCH_CONVERT)),
- tmp);
+ memset((char *)XFS_DIR_LEAF_NAMESTRUCT(leaf_s, INT_GET(entry_s->nameidx, ARCH_CONVERT)),
+ 0, tmp);
INT_MOD(hdr_s->namebytes, ARCH_CONVERT, -(entry_d->namelen));
INT_MOD(hdr_d->namebytes, ARCH_CONVERT, entry_d->namelen);
INT_MOD(hdr_s->count, ARCH_CONVERT, -1);
tmp = count * (uint)sizeof(xfs_dir_leaf_entry_t);
entry_s = &leaf_s->entries[start_s];
ASSERT((char *)entry_s + tmp <= (char *)leaf_s + XFS_LBSIZE(mp));
- bzero((char *)entry_s, tmp);
+ memset((char *)entry_s, 0, tmp);
} else {
/*
* Move the remaining entries down to fill the hole,
tmp *= (uint)sizeof(xfs_dir_leaf_entry_t);
entry_s = &leaf_s->entries[start_s + count];
entry_d = &leaf_s->entries[start_s];
- bcopy(entry_s, entry_d, tmp);
+ memcpy(entry_d, entry_s, tmp);
tmp = count * (uint)sizeof(xfs_dir_leaf_entry_t);
entry_s = &leaf_s->entries[INT_GET(hdr_s->count, ARCH_CONVERT)];
ASSERT((char *)entry_s + tmp <= (char *)leaf_s + XFS_LBSIZE(mp));
- bzero((char *)entry_s, tmp);
+ memset((char *)entry_s, 0, tmp);
}
/*
INT_ZERO(dic.di_gid, ARCH_CONVERT);
INT_ZERO(dic.di_nlink, ARCH_CONVERT);
INT_ZERO(dic.di_projid, ARCH_CONVERT);
- bzero(&(dic.di_pad[0]),sizeof(dic.di_pad));
+ memset(&(dic.di_pad[0]), 0, sizeof(dic.di_pad));
INT_SET(dic.di_atime.t_sec, ARCH_CONVERT, ztime.t_sec);
INT_SET(dic.di_atime.t_nsec, ARCH_CONVERT, ztime.t_nsec);
for (i = 0; i < ninodes; i++) {
free = XFS_MAKE_IPTR(args.mp, fbuf, i);
- bcopy (&dic, &(free->di_core), sizeof(xfs_dinode_core_t));
+ memcpy(&(free->di_core), &dic, sizeof(xfs_dinode_core_t));
INT_SET(free->di_next_unlinked, ARCH_CONVERT, NULLAGINO);
xfs_ialloc_log_di(tp, fbuf, i,
XFS_DI_CORE_BITS | XFS_DI_NEXT_UNLINKED);
return error;
}
#endif
- ovbcopy(&kp[ptr - 1], &kp[ptr],
+ memmove(&kp[ptr], &kp[ptr - 1],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr + 1) * sizeof(*kp));
- ovbcopy(&pp[ptr - 1], &pp[ptr],
+ memmove(&pp[ptr], &pp[ptr - 1],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr + 1) * sizeof(*pp));
/*
* Now stuff the new data in, bump numrecs and log the new data.
* It's a leaf entry. Make a hole for the new record.
*/
rp = XFS_INOBT_REC_ADDR(block, 1, cur);
- ovbcopy(&rp[ptr - 1], &rp[ptr],
+ memmove(&rp[ptr], &rp[ptr - 1],
(INT_GET(block->bb_numrecs, ARCH_CONVERT) - ptr + 1) * sizeof(*rp));
/*
* Now stuff the new record in, bump numrecs
return error;
}
#endif
- ovbcopy(rkp + 1, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- ovbcopy(rpp + 1, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memmove(rkp, rkp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memmove(rpp, rpp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
xfs_inobt_log_keys(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
xfs_inobt_log_ptrs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
} else {
- ovbcopy(rrp + 1, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memmove(rrp, rrp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
xfs_inobt_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
key.ir_startino = rrp->ir_startino; /* INT_: direct copy */
rkp = &key;
return error;
}
#endif
- ovbcopy(rkp, rkp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- ovbcopy(rpp, rpp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memmove(rkp + 1, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memmove(rpp + 1, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
#ifdef DEBUG
if ((error = xfs_btree_check_sptr(cur, INT_GET(*lpp, ARCH_CONVERT), level)))
return error;
} else {
lrp = XFS_INOBT_REC_ADDR(left, INT_GET(left->bb_numrecs, ARCH_CONVERT), cur);
rrp = XFS_INOBT_REC_ADDR(right, 1, cur);
- ovbcopy(rrp, rrp + 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memmove(rrp + 1, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
*rrp = *lrp;
xfs_inobt_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT) + 1);
key.ir_startino = rrp->ir_startino; /* INT_: direct copy */
return error;
}
#endif
- bcopy(lkp, rkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
- bcopy(lpp, rpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
+ memcpy(rkp, lkp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rkp));
+ memcpy(rpp, lpp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rpp));
xfs_inobt_log_keys(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
xfs_inobt_log_ptrs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
*keyp = *rkp;
else {
lrp = XFS_INOBT_REC_ADDR(left, i, cur);
rrp = XFS_INOBT_REC_ADDR(right, 1, cur);
- bcopy(lrp, rrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
+ memcpy(rrp, lrp, INT_GET(right->bb_numrecs, ARCH_CONVERT) * sizeof(*rrp));
xfs_inobt_log_recs(cur, rbp, 1, INT_GET(right->bb_numrecs, ARCH_CONVERT));
keyp->ir_startino = rrp->ir_startino; /* INT_: direct copy */
}
/*
* If the size is unreasonable, then something
* is wrong and we just bail out rather than crash in
- * kmem_alloc() or bcopy() below.
+ * kmem_alloc() or memcpy() below.
*/
if (size > XFS_DFORK_SIZE_ARCH(dip, ip->i_mount, whichfork, ARCH_CONVERT)) {
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
ifp->if_bytes = size;
ifp->if_real_bytes = real_size;
if (size)
- bcopy(XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_CONVERT), ifp->if_u1.if_data, size);
+ memcpy(ifp->if_u1.if_data,
+ XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_CONVERT), size);
ifp->if_flags &= ~XFS_IFEXTENTS;
ifp->if_flags |= XFS_IFINLINE;
return 0;
/*
* If the number of extents is unreasonable, then something
* is wrong and we just bail out rather than crash in
- * kmem_alloc() or bcopy() below.
+ * kmem_alloc() or memcpy() below.
*/
if (size < 0 || size > XFS_DFORK_SIZE_ARCH(dip, ip->i_mount, whichfork, ARCH_CONVERT)) {
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
xfs_validate_extents(
(xfs_bmbt_rec_32_t *)XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_CONVERT),
nex, XFS_EXTFMT_INODE(ip));
- bcopy(XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_CONVERT), ifp->if_u1.if_extents,
- size);
+ memcpy(ifp->if_u1.if_extents,
+ XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_CONVERT), size);
xfs_bmap_trace_exlist("xfs_iformat_extents", ip, nex,
whichfork);
if (whichfork != XFS_DATA_FORK ||
if (arch == ARCH_NOCONVERT) {
if (dir>0) {
- bcopy((xfs_caddr_t)buf_core, (xfs_caddr_t)mem_core, sizeof(xfs_dinode_core_t));
+ memcpy((xfs_caddr_t)mem_core, (xfs_caddr_t)buf_core, sizeof(xfs_dinode_core_t));
} else {
- bcopy((xfs_caddr_t)mem_core, (xfs_caddr_t)buf_core, sizeof(xfs_dinode_core_t));
+ memcpy((xfs_caddr_t)buf_core, (xfs_caddr_t)mem_core, sizeof(xfs_dinode_core_t));
}
return;
}
INT_XLATE(buf_core->di_projid, mem_core->di_projid, dir, arch);
if (dir>0) {
- bcopy(buf_core->di_pad, mem_core->di_pad, sizeof(buf_core->di_pad));
+ memcpy(mem_core->di_pad, buf_core->di_pad, sizeof(buf_core->di_pad));
} else {
- bcopy(mem_core->di_pad, buf_core->di_pad, sizeof(buf_core->di_pad));
+ memcpy(buf_core->di_pad, mem_core->di_pad, sizeof(buf_core->di_pad));
}
INT_XLATE(buf_core->di_atime.t_sec, mem_core->di_atime.t_sec, dir, arch);
ifp->if_broot_bytes = (int)new_size;
ASSERT(ifp->if_broot_bytes <=
XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
- ovbcopy(op, np, cur_max * (uint)sizeof(xfs_dfsbno_t));
+ memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t));
return;
}
/*
* First copy over the btree block header.
*/
- bcopy(ifp->if_broot, new_broot, sizeof(xfs_bmbt_block_t));
+ memcpy(new_broot, ifp->if_broot, sizeof(xfs_bmbt_block_t));
} else {
new_broot = NULL;
ifp->if_flags &= ~XFS_IFBROOT;
ifp->if_broot_bytes);
np = (char *)XFS_BMAP_BROOT_REC_ADDR(new_broot, 1,
(int)new_size);
- bcopy(op, np, new_max * (uint)sizeof(xfs_bmbt_rec_t));
+ memcpy(np, op, new_max * (uint)sizeof(xfs_bmbt_rec_t));
/*
* Then copy the pointers.
ifp->if_broot_bytes);
np = (char *)XFS_BMAP_BROOT_PTR_ADDR(new_broot, 1,
(int)new_size);
- bcopy(op, np, new_max * (uint)sizeof(xfs_dfsbno_t));
+ memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t));
}
kmem_free(ifp->if_broot, ifp->if_broot_bytes);
ifp->if_broot = new_broot;
* so the if_extents pointer is null.
*/
if (ifp->if_u1.if_extents) {
- bcopy(ifp->if_u1.if_extents,
- ifp->if_u2.if_inline_ext, new_size);
+ memcpy(ifp->if_u2.if_inline_ext,
+ ifp->if_u1.if_extents, new_size);
kmem_free(ifp->if_u1.if_extents,
ifp->if_real_bytes);
}
if (ifp->if_u1.if_extents == ifp->if_u2.if_inline_ext) {
ifp->if_u1.if_extents = (xfs_bmbt_rec_t *)
kmem_alloc(rnew_size, KM_SLEEP);
- bcopy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents,
+ memcpy(ifp->if_u1.if_extents, ifp->if_u2.if_inline_ext,
sizeof(ifp->if_u2.if_inline_ext));
} else if (rnew_size != ifp->if_real_bytes) {
ifp->if_u1.if_extents = (xfs_bmbt_rec_t *)
ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
} else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
ASSERT(ifp->if_real_bytes != 0);
- bcopy(ifp->if_u1.if_data, ifp->if_u2.if_inline_data,
+ memcpy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data,
new_size);
kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
} else {
ASSERT(ifp->if_real_bytes == 0);
ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
- bcopy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data,
- ifp->if_bytes);
+ memcpy(ifp->if_u1.if_data, ifp->if_u2.if_inline_data,
+ ifp->if_bytes);
}
}
ifp->if_real_bytes = real_size;
* returns the number of bytes copied into the buffer.
*
* If there are no delayed allocation extents, then we can just
- * bcopy() the extents into the buffer. Otherwise, we need to
+ * memcpy() the extents into the buffer. Otherwise, we need to
* examine each extent in turn and skip those which are delayed.
*/
int
ASSERT(ifp->if_bytes ==
(XFS_IFORK_NEXTENTS(ip, whichfork) *
(uint)sizeof(xfs_bmbt_rec_t)));
- bcopy(ifp->if_u1.if_extents, buffer, ifp->if_bytes);
+ memcpy(buffer, ifp->if_u1.if_extents, ifp->if_bytes);
xfs_validate_extents(buffer, nrecs, XFS_EXTFMT_INODE(ip));
return ifp->if_bytes;
}
(ifp->if_bytes > 0)) {
ASSERT(ifp->if_u1.if_data != NULL);
ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
- bcopy(ifp->if_u1.if_data, cp, ifp->if_bytes);
+ memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes);
}
if (whichfork == XFS_DATA_FORK) {
if (XFS_DIR_SHORTFORM_VALIDATE_ONDISK(mp, dip)) {
case XFS_DINODE_FMT_UUID:
if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) {
ASSERT(whichfork == XFS_DATA_FORK);
- bcopy(&ip->i_df.if_u2.if_uuid, &dip->di_u.di_muuid,
+ memcpy(&dip->di_u.di_muuid, &ip->i_df.if_u2.if_uuid,
sizeof(uuid_t));
}
break;
size == 1 ||
xfs_sb_info[f].type == 1) {
if (dir > 0) {
- bcopy(buf_ptr + first, mem_ptr + first, size);
+ memcpy(mem_ptr + first, buf_ptr + first, size);
} else {
- bcopy(mem_ptr + first, buf_ptr + first, size);
+ memcpy(buf_ptr + first, mem_ptr + first, size);
}
} else {
switch (size) {
* overwrite the unmount record after a clean unmount.
*
* Do this only if we are going to recover the filesystem
+ *
+ * NOTE: This used to say "if (!readonly)"
+ * However on Linux, we can & do recover a read-only filesystem.
+ * We only skip recovery if NORECOVERY is specified on mount,
+ * in which case we would not be here.
+ *
+ * But... if the -device- itself is readonly, just skip this.
+ * We can't recover this device anyway, so it won't matter.
*/
- if (!readonly)
+
+ if (!is_read_only(log->l_mp->m_logdev_targp->pbr_kdev)) {
error = xlog_clear_stale_blocks(log, tail_lsn);
+ }
#endif
bread_err:
* will appear in the current log item.
*/
STATIC int
-xlog_recover_add_to_trans(xlog_recover_t *trans,
+ xlog_recover_add_to_trans(xlog_recover_t *trans,
xfs_caddr_t dp,
int len)
{
if (!len)
return 0;
ptr = kmem_zalloc(len, 0);
- bcopy(dp, ptr, len);
+ memcpy(ptr, dp, len);
in_f = (xfs_inode_log_format_t *)ptr;
item = trans->r_itemq;
ASSERT(*(uint *)dp == XFS_TRANS_HEADER_MAGIC);
if (len == sizeof(xfs_trans_header_t))
xlog_recover_add_item(&trans->r_itemq);
- bcopy(dp, &trans->r_theader, len); /* s, d, l */
+ memcpy(&trans->r_theader, dp, len); /* d, s, l */
return 0;
}
if (item->ri_prev->ri_total != 0 &&
/* finish copying rest of trans header */
xlog_recover_add_item(&trans->r_itemq);
ptr = (xfs_caddr_t)&trans->r_theader+sizeof(xfs_trans_header_t)-len;
- bcopy(dp, ptr, len); /* s, d, l */
+ memcpy(ptr, dp, len); /* d, s, l */
return 0;
}
item = item->ri_prev;
old_len = item->ri_buf[item->ri_cnt-1].i_len;
ptr = kmem_realloc(old_ptr, len+old_len, old_len, 0);
- bcopy(dp , &ptr[old_len], len); /* s, d, l */
+ memcpy(&ptr[old_len], dp, len); /* d, s, l */
item->ri_buf[item->ri_cnt-1].i_len += len;
item->ri_buf[item->ri_cnt-1].i_addr = ptr;
return 0;
return ENOMEM;
}
- bzero(rhash, sizeof(rhash));
+ memset(rhash, 0, sizeof(rhash));
if (tail_blk <= head_blk) {
for (blk_no = tail_blk; blk_no < head_blk; ) {
if ((error = xlog_bread(log, blk_no, hblks, hbp)))
projects / thirdparty / xfsprogs-dev.git / commitdiff
