自学教程：C++ pwrite64函数代码示例

static intwrite_note(int fd, uint_t type, const void *desc, size_t descsz, off64_t *offp){	/*	 * Note headers are the same regardless of the data model of the	 * ELF file; we arbitrarily use Elf64_Nhdr here.	 */	struct {		Elf64_Nhdr nhdr;		char name[8];	} n;	bzero(&n, sizeof (n));	bcopy("CORE", n.name, 4);	n.nhdr.n_type = type;	n.nhdr.n_namesz = 5;	n.nhdr.n_descsz = roundup(descsz, 4);	if (pwrite64(fd, &n, sizeof (n), *offp) != sizeof (n))		return (-1);	*offp += sizeof (n);	if (pwrite64(fd, desc, n.nhdr.n_descsz, *offp) != n.nhdr.n_descsz)		return (-1);	*offp += n.nhdr.n_descsz;	return (0);}

// FlowField2D constructorint FlowField2D::SaveFlowField2D(char* filename){    int   fd_g,pf;    ostream*     o_stream = &cout;    ofstream*    f_stream = (ofstream*)(o_stream);        ssize_t max_write = 1024L*1024L*1024L;                                                                                                          ssize_t one_write = 0L;                                                                                                                         ssize_t len  = 0L;                                                                                                                            off_t  off = 0L;                                                                                                                               LoadSwapFile2D(filename,GetX(),GetY(),sizeof(FlowNode2D< FP, NUM_COMPONENTS>),&pf,&fd_g,f_stream);    char*  TmpPtr=(char*)GetMatrixPtr();                                                                                                                 if(GetMatrixSize() > max_write) {                                                                                                                         for(off = 0L,one_write = max_write; len < GetMatrixSize(); off += max_write) {                                                                           len += pwrite64(fd_g,TmpPtr+off,one_write,off);                                                                                                  if(GetMatrixSize() - len < max_write)                                                                                                                   one_write = GetMatrixSize() - len;                                                                                                                  }                                                                                                                                             if(len != GetMatrixSize())                                                                                                                              *f_stream << "Error: len(" << len << ") != MatrixSize(" << GetMatrixSize() << ") " << endl << flush;                                                   } else {                                                                                                                                           len = pwrite64(fd_g,GetMatrixPtr(),GetMatrixSize(),0L);                                                                                                   }    close(fd_g);    return len;}

static int fusecow_write(const char *path, const char *buf, size_t size,                     off64_t offset, struct fuse_file_info *fi){    (void) fi;    long long int block_number = offset / block_size;    if(offset + size > (block_number+1)*block_size) {	size = (block_number+1)*block_size - offset; // write only one block. write_safe will care    }    int res;    if(write_map_get(block_number)) {	res=pwrite64(fd_write, buf, size, offset);    } else {	int remaining = block_size;	while(remaining) {	    res=pread64(fd, copyup_buffer + block_size - remaining, remaining, block_number*block_size);	    if(res==0) {		memset(copyup_buffer + block_size - remaining, 0, remaining);		break;	    }	    if(res==-1) {		if(errno==EINTR) continue;		return -errno;	    }	    remaining -= res;	}	memcpy(copyup_buffer+offset%block_size, buf, size);	remaining=block_size;	while(remaining) {	    fprintf(stderr, "Performing write at offset %lld/n", block_number*block_size);	    res=pwrite64(fd_write, copyup_buffer + block_size - remaining, remaining, block_number*block_size);	    if(res==-1) {		if(errno==EINTR) continue;		return -errno;	    }	    remaining -= res;	}    write_map_set(block_number, 1);	res = size;    }    if (res == -1) {        res = -errno;    }     return res;}

static intwrite_shdr(pgcore_t *pgc, shstrtype_t name, uint_t type, ulong_t flags,    uintptr_t addr, ulong_t offset, size_t size, uint_t link, uint_t info,    uintptr_t addralign, uintptr_t entsize){	if (pgc->P->status.pr_dmodel == PR_MODEL_ILP32) {		Elf32_Shdr shdr;		bzero(&shdr, sizeof (shdr));		shdr.sh_name = shstrtab_ndx(&pgc->pgc_shstrtab, name);		shdr.sh_type = type;		shdr.sh_flags = flags;		shdr.sh_addr = (Elf32_Addr)addr;		shdr.sh_offset = offset;		shdr.sh_size = size;		shdr.sh_link = link;		shdr.sh_info = info;		shdr.sh_addralign = addralign;		shdr.sh_entsize = entsize;		if (pwrite64(pgc->pgc_fd, &shdr, sizeof (shdr),		    *pgc->pgc_soff) != sizeof (shdr))			return (-1);		*pgc->pgc_soff += sizeof (shdr);#ifdef _LP64	} else {		Elf64_Shdr shdr;		bzero(&shdr, sizeof (shdr));		shdr.sh_name = shstrtab_ndx(&pgc->pgc_shstrtab, name);		shdr.sh_type = type;		shdr.sh_flags = flags;		shdr.sh_addr = addr;		shdr.sh_offset = offset;		shdr.sh_size = size;		shdr.sh_link = link;		shdr.sh_info = info;		shdr.sh_addralign = addralign;		shdr.sh_entsize = entsize;		if (pwrite64(pgc->pgc_fd, &shdr, sizeof (shdr),		    *pgc->pgc_soff) != sizeof (shdr))			return (-1);		*pgc->pgc_soff += sizeof (shdr);#endif	/* _LP64 */	}	return (0);}

int write_dev_supers(struct btrfs_root *root, struct btrfs_super_block *sb,		     struct btrfs_device *device){	u64 bytenr;	u32 crc;	int i, ret;	if (root->fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) {		btrfs_set_super_bytenr(sb, root->fs_info->super_bytenr);		crc = ~(u32)0;		crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,				      BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);		btrfs_csum_final(crc, (char *)&sb->csum[0]);		/*		 * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is		 * zero filled, we can use it directly		 */		ret = pwrite64(device->fd, root->fs_info->super_copy,				BTRFS_SUPER_INFO_SIZE,				root->fs_info->super_bytenr);		BUG_ON(ret != BTRFS_SUPER_INFO_SIZE);		return 0;	}	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {		bytenr = btrfs_sb_offset(i);		if (bytenr + BTRFS_SUPER_INFO_SIZE > device->total_bytes)			break;		btrfs_set_super_bytenr(sb, bytenr);		crc = ~(u32)0;		crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,				      BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);		btrfs_csum_final(crc, (char *)&sb->csum[0]);		/*		 * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is		 * zero filled, we can use it directly		 */		ret = pwrite64(device->fd, root->fs_info->super_copy,				BTRFS_SUPER_INFO_SIZE, bytenr);		BUG_ON(ret != BTRFS_SUPER_INFO_SIZE);	}	return 0;}

file_error osd_write(osd_file *file, const void *buffer, UINT64 offset, UINT32 count, UINT32 *actual){	UINT32 result;   switch (file->type)   {      case SDLFILE_FILE:#if defined(SDLMAME_DARWIN) || defined(SDLMAME_BSD)         result = pwrite(file->handle, buffer, count, offset);         if (!result)#elif defined(SDLMAME_WIN32) || defined(SDLMAME_NO64BITIO) || defined(SDLMAME_OS2) || defined(__CELLOS_LV2__)         lseek(file->handle, (UINT32)offset&0xffffffff, SEEK_SET);         result = write(file->handle, buffer, count);         if (!result)#elif defined(SDLMAME_UNIX)         result = pwrite64(file->handle, buffer, count, offset);         if (!result)#else#error Unknown SDL SUBARCH!#endif		return error_to_file_error(errno);         if (actual != NULL)            *actual = result;         return FILERR_NONE;         break;      default:         return FILERR_FAILURE;    }}

void Driver_FILE::set_frame(const int frameid, const Frame& frame){#if defined(__MACH__)    pthread_mutex_lock(&spinlock);#else    pthread_spin_lock(&spinlock);#endif      if(objmask.find(frameid) != objmask.end()){    // if in hash#ifdef __MACH__      ret = pwrite(fd, frame.content, this->framesize_in_byte, 1L*frameid*this->framesize_in_byte);#else      ret = pwrite64(fd, frame.content, this->framesize_in_byte, 1L*frameid*this->framesize_in_byte);#endif    if(ret < 0){      assert(false && "Driver_FILE: fail to write in set()");    }  }else{    assert(false && "Driver_FILE: key not in hash");  }    #if defined(__MACH__)    pthread_mutex_unlock(&spinlock);#else    pthread_spin_unlock(&spinlock);#endif}

void Driver_FILE::add_frame(const int frameid){  assert(frameid >= 0 && "Driver_FILE: only support INTEGER-many frames for now. If you want larger storage, please increase the framesize instead.");#if defined(__MACH__)  pthread_mutex_lock(&spinlock);#else  pthread_spin_lock(&spinlock);#endif      if(objmask.find(frameid) != objmask.end()){    // if already contains the key, error    assert(false && "Driver_FILE: duplicate key init'ed");  }else{    // else, insert using the default constructor    objmask[frameid] = true;  }      #ifdef __MACH__    ret = pwrite(fd, empty_frame.content, this->framesize_in_byte, 1L*frameid*this->framesize_in_byte);  #else    ret = pwrite64(fd, empty_frame.content, this->framesize_in_byte, 1L*frameid*this->framesize_in_byte);  #endif    if(ret < 0){    assert(false && "Driver_FILE: fail to write in init()");  }    #if defined(__MACH__)    pthread_mutex_unlock(&spinlock);#else    pthread_spin_unlock(&spinlock);#endif}

intpci_vfio_write_config(const struct rte_intr_handle *intr_handle,		    const void *buf, size_t len, off_t offs){	return pwrite64(intr_handle->vfio_dev_fd, buf, len,	       VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);}

/* * Given a file descriptor, clear (zero) the label information. */intzpool_clear_label(int fd){	struct stat statbuf;	int l;	vdev_label_t *label;	uint64_t size;	if (fstat_blk(fd, &statbuf) == -1)		return (0);	size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);	if ((label = calloc(sizeof (vdev_label_t), 1)) == NULL)		return (-1);	for (l = 0; l < VDEV_LABELS; l++) {		if (pwrite64(fd, label, sizeof (vdev_label_t),		    label_offset(size, l)) != sizeof (vdev_label_t)) {			free(label);			return (-1);		}	}	free(label);	return (0);}

static introot_write(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, caller_context_t *ct){    ASSERT(vp->v_fd != -1);    ASSERT(vp->v_type != VBLK || IS_P2ALIGNED(uiop->uio_loffset, 512));    ASSERT(vp->v_type != VBLK || IS_P2ALIGNED(uiop->uio_iov->iov_len, 512));    int error = 0;    ssize_t iolen = pwrite64(vp->v_fd, uiop->uio_iov->iov_base, uiop->uio_iov->iov_len, uiop->uio_loffset);    if(iolen == -1) {        error = errno;        perror("pwrite64");    }    if(iolen != uiop->uio_iov->iov_len)        fprintf(stderr, "root_write(): len: %lli iolen: %lli offset: %lli file: %s/n", (longlong_t) uiop->uio_iov->iov_len, (longlong_t) iolen, (longlong_t) uiop->uio_loffset, vp->v_path);    if(error)        return error;    uiop->uio_resid -= iolen;    return 0;}

static int fusecow_write_safe(const char *path, const char *buf, size_t size,                     off64_t offset, struct fuse_file_info *fi){    int res=0;    if(strcmp(path, "/") != 0)        return -ENOENT;    size_t remaining = size;    while(remaining) {	int ret=fusecow_write(path, buf+res, remaining, offset+res, fi);	if(ret==0) {	    break;	}	if(ret==-1) {	    if(errno==EINTR) continue;	    return -errno;	}	res+=ret;	remaining-=ret;    }        if(offset+res > st_size) {	fprintf(stderr, "Growing files is known to fail/n");	return -ENOSPC;	st_size = offset+res;    if(mem_write_map!=MAP_FAILED) {        memcpy(mem_write_map+8, &st_size, sizeof st_size);	} else {        pwrite64(fd_write_map, &st_size, sizeof st_size, 8);	}    }    return res;}

void write_map_set(long long int block, char val) {    long long int offset = 32 + block/8;        if((mem_write_map!=MAP_FAILED) && (offset > mem_write_map_size) ) {    munmap(mem_write_map, mem_write_map_size);    mem_write_map_size = (block/8/getpagesize()+1)*getpagesize();    ftruncate(fd_write_map, mem_write_map_size);    mem_write_map = mmap(NULL, mem_write_map_size , PROT_READ|PROT_WRITE, MAP_SHARED, fd_write_map, 0);    }    char c;    if(mem_write_map!=MAP_FAILED) {    c = mem_write_map[offset];    } else {        pread64(fd_write_map, &c, 1, offset);    }    char mask = 1 << (block%8);    c &= ~mask;    if(val) {	c |= mask;    }    if(mem_write_map!=MAP_FAILED) {    mem_write_map[offset]=c;    } else {        pwrite64(fd_write_map, &c, 1, offset);    }}

static int write_block(int fd, void *buf, unsigned long block,		unsigned long block_size){	char		*b;	off64_t		offset;	unsigned long	remaining;	ssize_t		rc;	b		= buf;	offset		= block * block_size;	remaining	= block_size;	while (remaining > 0) {		rc = pwrite64(fd, b, remaining, offset);		if (rc < 0) {			if (errno == EINTR)				continue;			fprintf(stderr, "write failed: %s/n", strerror(errno));			return -1;		}		b		+= rc;		offset		+= rc;		remaining	-= rc;	}	return 0;}

static int write_verity_state(const char *fname, off64_t offset, int32_t mode){    int fd;    int rc = -1;    struct verity_state s = { VERITY_STATE_HEADER, VERITY_STATE_VERSION, mode };    fd = TEMP_FAILURE_RETRY(open(fname, O_WRONLY | O_SYNC | O_CLOEXEC));    if (fd == -1) {        PERROR << "Failed to open " << fname;        goto out;    }    if (TEMP_FAILURE_RETRY(pwrite64(fd, &s, sizeof(s), offset)) != sizeof(s)) {        PERROR << "Failed to write " << sizeof(s) << " bytes to " << fname               << " to offset " << offset;        goto out;    }    rc = 0;out:    if (fd != -1) {        close(fd);    }    return rc;}

static voidPwrite(int fd, void *buf, size_t size, off64_t off){	if (pwrite64(fd, buf, size, off) != size)		logprint(SC_SL_ERR | SC_EXIT_ERR, "pwrite: %s",		    strerror(errno));}

ssize_t RandomAccessFile::write(uint64_t offset, void* src, size_t size){	BOOST_ASSERT( size <= WINDOW_SIZE );	ssize_t written = pwrite64(_fd, src, size, offset);	if ((size_t)written != size)		throw std::ios_base::failure("Failed to write");	return written;}

ssize_t full_pwrite64(int fd, const void *buf, size_t count, int64_t offset){#if CCTOOLS_OPSYS_CYGWIN || CCTOOLS_OPSYS_DARWIN || CCTOOLS_OPSYS_FREEBSD || CCTOOLS_OPSYS_DRAGONFLY	FULL_PIO(pwrite(fd, buf, count, offset));#else	FULL_PIO(pwrite64(fd, buf, count, offset));#endif}

static intpci_device_linux_sysfs_write( struct pci_device * dev, const void * data,			     pciaddr_t offset, pciaddr_t size,			     pciaddr_t * bytes_written ){    char name[256];    pciaddr_t temp_size = size;    int err = 0;    int fd;    const char *data_bytes = data;    if ( bytes_written != NULL ) {	*bytes_written = 0;    }    /* Each device has a directory under sysfs.  Within that directory there     * is a file named "config".  This file used to access the PCI config     * space.  It is used here to obtain most of the information about the     * device.     */    snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",	      SYS_BUS_PCI,	      dev->domain,	      dev->bus,	      dev->dev,	      dev->func );    fd = open( name, O_WRONLY | O_CLOEXEC);    if ( fd == -1 ) {	return errno;    }    while ( temp_size > 0 ) {	const ssize_t bytes = pwrite64( fd, data_bytes, temp_size, offset );	/* If zero bytes were written, then we assume it's the end of the	 * config file.	 */	if ( bytes == 0 )	    break;	if ( bytes < 0 ) {	    err = errno;	    break;	}	temp_size -= bytes;	offset += bytes;	data_bytes += bytes;    }    if ( bytes_written != NULL ) {	*bytes_written = size - temp_size;    }    close( fd );    return err;}

int write_file(int fd, unsigned long long *offset, const char *buf, int len){	int n;	n = pwrite64(fd, buf, len, *offset);	if(n < 0) return(-errno);	*offset += n;	return(n);}

JNIEXPORT jint JNICALLJava_sun_nio_ch_FileDispatcher_pwrite0(JNIEnv *env, jclass clazz, jobject fdo,                            jlong address, jint len, jlong offset){    jint fd = fdval(env, fdo);    void *buf = (void *)jlong_to_ptr(address);    return convertReturnVal(env, pwrite64(fd, buf, len, offset), JNI_FALSE);}

static intwrite_backward(	off64_t		offset,	long long	*count,	long long	*total){	off64_t		end, off = offset;	ssize_t		bytes = 0, bytes_requested;	long long	cnt = *count;	int		ops = 0;	if ((end = off - cnt) < 0) {		cnt += end;	/* subtraction, end is negative */		end = 0;	}	*total = 0;	*count = cnt;	/* Do initial unaligned write if needed */	if ((bytes_requested = (off % buffersize))) {		bytes_requested = min(cnt, bytes_requested);		off -= bytes_requested;		bytes = pwrite(file->fd, buffer, bytes_requested, off);		if (bytes == 0)			return ops;		if (bytes < 0) {			perror("pwrite64");			return -1;		}		ops++;		*total += bytes;		if (bytes < bytes_requested)			return ops;		cnt -= bytes;	}	/* Iterate backward through the rest of the range */	while (cnt > end) {		bytes_requested = min(cnt, buffersize);		off -= bytes_requested;		bytes = pwrite64(file->fd, buffer, bytes_requested, off);		if (bytes == 0)			break;		if (bytes < 0) {			perror("pwrite64");			return -1;		}		ops++;		*total += bytes;		if (bytes < bytes_requested)			break;		cnt -= bytes;	}	return ops;}

ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,		loff_t offset){#ifdef USE_UBLIO	return ublio_pwrite(dev->ufh, buffer, size, offset);#elif defined(__ANDROID__)    return pwrite64(dev->fd, buffer, size, offset);#else	return pwrite(dev->fd, buffer, size, offset);#endif}

ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,		off64_t offset){#ifdef USE_UBLIO	return ublio_pwrite(dev->ufh, buffer, size, offset);#elif defined(USE_TRANSITIONAL_LFS) && USE_TRANSITIONAL_LFS	return pwrite64(dev->fd, buffer, size, offset);#else	return pwrite(dev->fd, buffer, size, offset);#endif}

static intdo_pwrite(	int		fd,	off64_t		offset,	ssize_t		count,	ssize_t		buffer_size){	if (!vectors)		return pwrite64(fd, buffer, min(count, buffer_size), offset);	return do_pwritev(fd, offset, count, buffer_size);}

tb_long_t tb_file_pwrit(tb_file_ref_t file, tb_byte_t const* data, tb_size_t size, tb_hize_t offset){    // check    tb_assert_and_check_return_val(file, -1);    // writ it#ifdef TB_CONFIG_POSIX_HAVE_PWRITE64    return pwrite64(tb_file2fd(file), data, (size_t)size, offset);#else    return pwrite(tb_file2fd(file), data, (size_t)size, offset);#endif}

extern "C" ssize_t __pwrite64_chk(int fd, const void* buf, size_t count, off64_t offset,                                  size_t buf_size) {  if (__predict_false(count > buf_size)) {    __fortify_chk_fail("pwrite64: prevented read past end of buffer", 0);  }  if (__predict_false(count > SSIZE_MAX)) {    __fortify_chk_fail("pwrite64: count > SSIZE_MAX", 0);  }  return pwrite64(fd, buf, count, offset);}

void CloseSwapFile(char*   SwapFileName,                   void*   SwapData,                   ssize_t  FileSize,                   int     fd,                   int     isDel#ifdef _MPI                   ,int rank#endif //_MPI                  ) {#ifdef WRITE_LARGE_FILE#warning "Write file > 2Gb"        ssize_t max_write = 1024L*1024L*1024L;    ssize_t one_write = 0L;    ssize_t len  = 0L;    off_t  off = 0L;    char*  TmpPtr=(char*)SwapData;    if ( FileSize > max_write ) {        for ( off = 0L,one_write = max_write; len < FileSize; off += max_write ) {            len += pwrite64(fd,TmpPtr+off,one_write,off);            if ( FileSize - len < max_write )                one_write = FileSize - len;        }        if ( len != FileSize )#ifdef _MPI            if ( rank == 0 )#endif //_MPI                cout << "Error: len(" << len << ") != FileSize(" << FileSize << ") " << endl << flush;    } else {        len = pwrite64(fd,SwapData,FileSize,0L);    }#else    msync(SwapData,FileSize,MS_SYNC);#endif // WRITE_LARGE_FILE     munmap(SwapData,FileSize);    close(fd);#ifdef _REMOVE_SWAPFILE_    if ( isDel ) unlink(SwapFileName);#endif //_REMOVE_SWAPFILE_    SwapData=NULL;}

ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off){	ssize_t ret;	do {#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)		ret = pwrite64(fd, buf, count, off);#else		ret = pwrite(fd, buf, count, off);#endif	} while (ret == -1 && errno == EINTR);	return ret;}

static intdump_symtab(pgcore_t *pgc, file_info_t *fptr, uint_t index, int dynsym){	sym_tbl_t *sym = dynsym ? &fptr->file_dynsym : &fptr->file_symtab;	shstrtype_t symname = dynsym ? STR_DYNSYM : STR_SYMTAB;	shstrtype_t strname = dynsym ? STR_DYNSTR : STR_STRTAB;	uint_t symtype = dynsym ? SHT_DYNSYM : SHT_SYMTAB;	size_t size;	uintptr_t addr = fptr->file_map->map_pmap.pr_vaddr;	if (sym->sym_data_pri == NULL || sym->sym_symn == 0 ||	    sym->sym_strs == NULL)		return (0);	size = sym->sym_hdr_pri.sh_size;	if (pwrite64(pgc->pgc_fd, sym->sym_data_pri->d_buf, size,	    *pgc->pgc_doff) != size)		return (-1);	if (write_shdr(pgc, symname, symtype, 0, addr, *pgc->pgc_doff, size,	    index + 1, sym->sym_hdr_pri.sh_info, sym->sym_hdr_pri.sh_addralign,	    sym->sym_hdr_pri.sh_entsize) != 0)		return (-1);	*pgc->pgc_doff += roundup(size, 8);	size = sym->sym_strhdr.sh_size;	if (pwrite64(pgc->pgc_fd, sym->sym_strs, size, *pgc->pgc_doff) != size)		return (-1);	if (write_shdr(pgc, strname, SHT_STRTAB, SHF_STRINGS, addr,	    *pgc->pgc_doff, size, 0, 0, 1, 0) != 0)		return (-1);	*pgc->pgc_doff += roundup(size, 8);	return (0);}