/* Determines whether an executable's header matches the current architecture, ppc, and/or i386. * Returns true if the header corresponds to a Mach-O, 64-bit Mach-O, or universal binary executable, false otherwise. * Returns by reference the result of matching against a given architecture (matches_current, matches_ppc, matches_i386). * Checks for a given architecture only if the corresponding return-by-reference argument is non-NULL. */ static Boolean examine_header(uint8_t *bytes, ssize_t length, Boolean *matches_current, Boolean *matches_ppc, Boolean *matches_i386) { Boolean retval = false; uint32_t magic = 0, num_fat = 0, max_fat = 0; struct fat_arch one_fat = {0}, *fat = NULL; const NXArchInfo *current_arch, *ppc_arch, *i386_arch; // Look for any of the six magic numbers relevant to Mach-O executables, and swap the header if necessary. if (length >= sizeof(struct mach_header_64)) { magic = *((uint32_t *)bytes); max_fat = (length - sizeof(struct fat_header)) / sizeof(struct fat_arch); if (MH_MAGIC == magic || MH_CIGAM == magic) { struct mach_header *mh = (struct mach_header *)bytes; if (MH_CIGAM == magic) swap_header(bytes, length); one_fat.cputype = mh->cputype; one_fat.cpusubtype = mh->cpusubtype; fat = &one_fat; num_fat = 1; } else if (MH_MAGIC_64 == magic || MH_CIGAM_64 == magic) { struct mach_header_64 *mh = (struct mach_header_64 *)bytes; if (MH_CIGAM_64 == magic) swap_header(bytes, length); one_fat.cputype = mh->cputype; one_fat.cpusubtype = mh->cpusubtype; fat = &one_fat; num_fat = 1; } else if (FAT_MAGIC == magic || FAT_CIGAM == magic) { fat = (struct fat_arch *)(bytes + sizeof(struct fat_header)); if (FAT_CIGAM == magic) swap_header(bytes, length); num_fat = ((struct fat_header *)bytes)->nfat_arch; if (num_fat > max_fat) num_fat = max_fat; } } // Set the return value depending on whether the header appears valid. retval = ((fat && num_fat > 0) ? true : false); // Check for a match against the current architecture specification, if requested. if (matches_current) { current_arch = NXGetLocalArchInfo(); *matches_current = ((retval && current_arch && NXFindBestFatArch(current_arch->cputype, current_arch->cpusubtype, fat, num_fat)) ? true : false); } // Check for a match against the ppc architecture specification, if requested. if (matches_ppc) { ppc_arch = NXGetArchInfoFromName("ppc"); *matches_ppc = ((retval && ppc_arch && NXFindBestFatArch(ppc_arch->cputype, ppc_arch->cpusubtype, fat, num_fat)) ? true : false); } // Check for a match against the i386 architecture specification, if requested. if (matches_i386) { i386_arch = NXGetArchInfoFromName("i386"); *matches_i386 = ((retval && i386_arch && NXFindBestFatArch(i386_arch->cputype, i386_arch->cpusubtype, fat, num_fat)) ? true : false); } return retval; }
static int write_f_header(FILE *fp, struct file_header *f_hdr) { int rc = 0; rewind(fp); swap_header(f_hdr); if (fwrite(f_hdr, sizeof(struct file_header) - sizeof(__u64), 1, fp) != 1) { fprintf(stderr, "%s: Failed to write" " header\n", toolname); rc = -1; } swap_header(f_hdr); return rc; }
IMDType imd_recv_header(void *s, int32_t *length) { IMDheader header; if (imd_readn(s, (char *)&header, HEADERSIZE) != HEADERSIZE) return IMD_IOERROR; swap_header(&header); *length = header.length; return (IMDType)header.type; }
/* Get the CBFS header out of the ROM and do endian conversion. */ static int file_cbfs_load_header(uintptr_t end_of_rom, struct cbfs_header *header) { struct cbfs_header *header_in_rom; int32_t offset = *(u32 *)(end_of_rom - 3); header_in_rom = (struct cbfs_header *)(end_of_rom + offset + 1); swap_header(header, header_in_rom); if (header->magic != good_magic || header->offset > header->rom_size - header->boot_block_size) { file_cbfs_result = CBFS_BAD_HEADER; return 1; } return 0; }
static int get_header(FILE *fp, struct file_header *hdr) { rewind(fp); if (fread(hdr, sizeof(struct file_header) - sizeof(__u64), 1, fp) != 1) { fprintf(stderr, "%s: Could not read header\n", toolname); return -1; } swap_header(hdr); if (hdr->magic != DATA_MGR_MAGIC) { fprintf(stderr, "%s: Unregocgnized data in .log file.\n", toolname); return -2; } if (check_version(hdr->version)) return -2; hdr->begin_time = 0; return 0; }
/* ARGSUSED */ DB * __hash_open(const char *file, int flags, int mode, const HASHINFO *info, /* Special directives for create */ int dflags) { HTAB *hashp; struct stat statbuf; DB *dbp; int bpages, hdrsize, new_table, nsegs, save_errno; if ((flags & O_ACCMODE) == O_WRONLY) { errno = EINVAL; return (NULL); } if (!(hashp = (HTAB *)calloc(1, sizeof(HTAB)))) return (NULL); hashp->fp = -1; /* * Even if user wants write only, we need to be able to read * the actual file, so we need to open it read/write. But, the * field in the hashp structure needs to be accurate so that * we can check accesses. */ hashp->flags = flags; if (file) { if ((hashp->fp = _open(file, flags | O_CLOEXEC, mode)) == -1) RETURN_ERROR(errno, error0); new_table = _fstat(hashp->fp, &statbuf) == 0 && statbuf.st_size == 0 && (flags & O_ACCMODE) != O_RDONLY; } else new_table = 1; if (new_table) { if (!(hashp = init_hash(hashp, file, info))) RETURN_ERROR(errno, error1); } else { /* Table already exists */ if (info && info->hash) hashp->hash = info->hash; else hashp->hash = __default_hash; hdrsize = _read(hashp->fp, &hashp->hdr, sizeof(HASHHDR)); #if BYTE_ORDER == LITTLE_ENDIAN swap_header(hashp); #endif if (hdrsize == -1) RETURN_ERROR(errno, error1); if (hdrsize != sizeof(HASHHDR)) RETURN_ERROR(EFTYPE, error1); /* Verify file type, versions and hash function */ if (hashp->MAGIC != HASHMAGIC) RETURN_ERROR(EFTYPE, error1); #define OLDHASHVERSION 1 if (hashp->VERSION != HASHVERSION && hashp->VERSION != OLDHASHVERSION) RETURN_ERROR(EFTYPE, error1); if ((int32_t)hashp->hash(CHARKEY, sizeof(CHARKEY)) != hashp->H_CHARKEY) RETURN_ERROR(EFTYPE, error1); /* * Figure out how many segments we need. Max_Bucket is the * maximum bucket number, so the number of buckets is * max_bucket + 1. */ nsegs = (hashp->MAX_BUCKET + 1 + hashp->SGSIZE - 1) / hashp->SGSIZE; if (alloc_segs(hashp, nsegs)) /* * If alloc_segs fails, table will have been destroyed * and errno will have been set. */ return (NULL); /* Read in bitmaps */ bpages = (hashp->SPARES[hashp->OVFL_POINT] + (hashp->BSIZE << BYTE_SHIFT) - 1) >> (hashp->BSHIFT + BYTE_SHIFT); hashp->nmaps = bpages; (void)memset(&hashp->mapp[0], 0, bpages * sizeof(u_int32_t *)); } /* Initialize Buffer Manager */ if (info && info->cachesize) __buf_init(hashp, info->cachesize); else __buf_init(hashp, DEF_BUFSIZE); hashp->new_file = new_table; hashp->save_file = file && (hashp->flags & O_RDWR); hashp->cbucket = -1; if (!(dbp = (DB *)malloc(sizeof(DB)))) { save_errno = errno; hdestroy(hashp); errno = save_errno; return (NULL); } dbp->internal = hashp; dbp->close = hash_close; dbp->del = hash_delete; dbp->fd = hash_fd; dbp->get = hash_get; dbp->put = hash_put; dbp->seq = hash_seq; dbp->sync = hash_sync; dbp->type = DB_HASH; #ifdef DEBUG (void)fprintf(stderr, "%s\n%s%p\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%x\n%s%x\n%s%d\n%s%d\n", "init_htab:", "TABLE POINTER ", hashp, "BUCKET SIZE ", hashp->BSIZE, "BUCKET SHIFT ", hashp->BSHIFT, "DIRECTORY SIZE ", hashp->DSIZE, "SEGMENT SIZE ", hashp->SGSIZE, "SEGMENT SHIFT ", hashp->SSHIFT, "FILL FACTOR ", hashp->FFACTOR, "MAX BUCKET ", hashp->MAX_BUCKET, "OVFL POINT ", hashp->OVFL_POINT, "LAST FREED ", hashp->LAST_FREED, "HIGH MASK ", hashp->HIGH_MASK, "LOW MASK ", hashp->LOW_MASK, "NSEGS ", hashp->nsegs, "NKEYS ", hashp->NKEYS); #endif #ifdef HASH_STATISTICS hash_overflows = hash_accesses = hash_collisions = hash_expansions = 0; #endif return (dbp); error1: if (hashp != NULL) (void)_close(hashp->fp); error0: free(hashp); errno = save_errno; return (NULL); }
/* * Read the next block from the tape. * Check to see if it is one of several vintage headers. * If it is an old style header, convert it to a new style header. * If it is not any valid header, return an error. */ static int gethead(struct s_spcl *buf) { union u_ospcl u_ospcl; if (!cvtflag) { readtape((char *)buf); if (buf->c_magic != NFS_MAGIC && buf->c_magic != FS_UFS2_MAGIC) { if (swap32(buf->c_magic) != NFS_MAGIC && swap32(buf->c_magic) != FS_UFS2_MAGIC) return (FAIL); if (!Bcvt) { Vprintf(stdout, "Note: Doing Byte swapping\n"); Bcvt = 1; } } if (checksum((int *)buf) == FAIL) return (FAIL); if (Bcvt) swap_header(buf); goto good; } readtape((char *)(&u_ospcl.s_ospcl)); if (checksum((int *)(&u_ospcl.s_ospcl)) == FAIL) return (FAIL); if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC) { if (swap32(u_ospcl.s_ospcl.c_magic) != OFS_MAGIC) return (FAIL); if (!Bcvt) { fprintf(stdout, "Note: Doing Byte swapping\n"); Bcvt = 1; } swap_old_header(&u_ospcl.s_ospcl); } memset(buf, 0, TP_BSIZE); buf->c_type = u_ospcl.s_ospcl.c_type; buf->c_date = u_ospcl.s_ospcl.c_date; buf->c_ddate = u_ospcl.s_ospcl.c_ddate; buf->c_volume = u_ospcl.s_ospcl.c_volume; buf->c_tapea = u_ospcl.s_ospcl.c_tapea; buf->c_inumber = u_ospcl.s_ospcl.c_inumber; buf->c_checksum = u_ospcl.s_ospcl.c_checksum; buf->c_mode = u_ospcl.s_ospcl.c_odinode.odi_mode; buf->c_uid = u_ospcl.s_ospcl.c_odinode.odi_uid; buf->c_gid = u_ospcl.s_ospcl.c_odinode.odi_gid; buf->c_size = u_ospcl.s_ospcl.c_odinode.odi_size; buf->c_rdev = u_ospcl.s_ospcl.c_odinode.odi_rdev; buf->c_atime = u_ospcl.s_ospcl.c_odinode.odi_atime; buf->c_mtime = u_ospcl.s_ospcl.c_odinode.odi_mtime; buf->c_count = u_ospcl.s_ospcl.c_count; memcpy(buf->c_addr, u_ospcl.s_ospcl.c_addr, 256); buf->c_magic = FS_UFS2_MAGIC; good: switch (buf->c_type) { case TS_CLRI: case TS_BITS: /* * Have to patch up missing information in bit map headers */ buf->c_inumber = 0; buf->c_size = buf->c_count * TP_BSIZE; break; case TS_TAPE: if ((buf->c_flags & DR_NEWINODEFMT) == 0) oldinofmt = 1; /* fall through */ case TS_END: buf->c_inumber = 0; break; case TS_INODE: if (buf->c_magic == NFS_MAGIC) { buf->c_tapea = buf->c_old_tapea; buf->c_firstrec = buf->c_old_firstrec; buf->c_date = buf->c_old_date; buf->c_ddate = buf->c_old_ddate; buf->c_atime = buf->c_old_atime; buf->c_mtime = buf->c_old_mtime; buf->c_birthtime = 0; buf->c_birthtimensec = 0; buf->c_atimensec = buf->c_mtimensec = 0; } case TS_ADDR: break; default: panic("gethead: unknown inode type %d\n", buf->c_type); break; } buf->c_magic = FS_UFS2_MAGIC; /* * If we are restoring a filesystem with old format inodes, * copy the uid/gid to the new location. */ if (oldinofmt) { buf->c_uid = buf->c_spare1[1]; buf->c_gid = buf->c_spare1[2]; } if (dflag) accthdr(buf); return(GOOD); }
extern DB * __hash_open(const char *file, int flags, int mode, const HASHINFO *info, int dflags) { HTAB *hashp=NULL; struct stat statbuf; DB *dbp; int bpages, hdrsize, new_table, nsegs, save_errno; if ((flags & O_ACCMODE) == O_WRONLY) { errno = EINVAL; return NULL; } /* zero the statbuffer so that * we can check it for a non-zero * date to see if stat succeeded */ memset(&statbuf, 0, sizeof(struct stat)); if (!(hashp = (HTAB *)calloc(1, sizeof(HTAB)))) { errno = ENOMEM; return NULL; } hashp->fp = NO_FILE; if(file) hashp->filename = strdup(file); /* * Even if user wants write only, we need to be able to read * the actual file, so we need to open it read/write. But, the * field in the hashp structure needs to be accurate so that * we can check accesses. */ hashp->flags = flags; new_table = 0; if (!file || (flags & O_TRUNC) || (stat(file, &statbuf) && (errno == ENOENT))) { if (errno == ENOENT) errno = 0; /* Just in case someone looks at errno */ new_table = 1; } else if(statbuf.st_mtime && statbuf.st_size == 0) { /* check for a zero length file and delete it * if it exists */ new_table = 1; } hashp->file_size = statbuf.st_size; if (file) { #if defined(_WIN32) || defined(_WINDOWS) || defined (macintosh) || defined(XP_OS2) if ((hashp->fp = DBFILE_OPEN(file, flags | O_BINARY, mode)) == -1) RETURN_ERROR(errno, error1); #else if ((hashp->fp = open(file, flags, mode)) == -1) RETURN_ERROR(errno, error1); (void)fcntl(hashp->fp, F_SETFD, 1); #endif } if (new_table) { if (!init_hash(hashp, file, (HASHINFO *)info)) RETURN_ERROR(errno, error1); } else { /* Table already exists */ if (info && info->hash) hashp->hash = info->hash; else hashp->hash = __default_hash; hdrsize = read(hashp->fp, (char *)&hashp->hdr, sizeof(HASHHDR)); if (hdrsize == -1) RETURN_ERROR(errno, error1); if (hdrsize != sizeof(HASHHDR)) RETURN_ERROR(EFTYPE, error1); #if BYTE_ORDER == LITTLE_ENDIAN swap_header(hashp); #endif /* Verify file type, versions and hash function */ if (hashp->MAGIC != HASHMAGIC) RETURN_ERROR(EFTYPE, error1); #define OLDHASHVERSION 1 if (hashp->VERSION != HASHVERSION && hashp->VERSION != OLDHASHVERSION) RETURN_ERROR(EFTYPE, error1); if (hashp->hash(CHARKEY, sizeof(CHARKEY)) != hashp->H_CHARKEY) RETURN_ERROR(EFTYPE, error1); if (hashp->NKEYS < 0) /* Old bad database. */ RETURN_ERROR(EFTYPE, error1); /* * Figure out how many segments we need. Max_Bucket is the * maximum bucket number, so the number of buckets is * max_bucket + 1. */ nsegs = (hashp->MAX_BUCKET + 1 + hashp->SGSIZE - 1) / hashp->SGSIZE; hashp->nsegs = 0; if (alloc_segs(hashp, nsegs)) /* If alloc_segs fails, errno will have been set. */ RETURN_ERROR(errno, error1); /* Read in bitmaps */ bpages = (hashp->SPARES[hashp->OVFL_POINT] + (hashp->BSIZE << BYTE_SHIFT) - 1) >> (hashp->BSHIFT + BYTE_SHIFT); hashp->nmaps = bpages; (void)memset(&hashp->mapp[0], 0, bpages * sizeof(uint32 *)); } /* Initialize Buffer Manager */ if (info && info->cachesize) __buf_init(hashp, (int32) info->cachesize); else __buf_init(hashp, DEF_BUFSIZE); hashp->new_file = new_table; #ifdef macintosh hashp->save_file = file && !(hashp->flags & O_RDONLY); #else hashp->save_file = file && (hashp->flags & O_RDWR); #endif hashp->cbucket = -1; if (!(dbp = (DB *)malloc(sizeof(DB)))) { RETURN_ERROR(ENOMEM, error1); } dbp->internal = hashp; dbp->close = hash_close; dbp->del = hash_delete; dbp->fd = hash_fd; dbp->get = hash_get; dbp->put = hash_put; dbp->seq = hash_seq; dbp->sync = hash_sync; dbp->type = DB_HASH; #ifdef HASH_STATISTICS hash_overflows = hash_accesses = hash_collisions = hash_expansions = 0; #endif return (dbp); error1: hdestroy(hashp); errno = save_errno; return (NULL); }
/*! This function reads a snapshot file and distributes the data it contains * to tasks 'readTask' to 'lastTask'. */ void read_file(char *fname, int readTask, int lastTask) { int blockmaxlen; int i, n_in_file, n_for_this_task, ntask, pc, offset = 0, task; int blksize1, blksize2; MPI_Status status; FILE *fd = 0; int nall, nread; int type, bnr; char label[4], expected_label[4], buf[500]; int nstart, bytes_per_blockelement, npart, nextblock, typelist[6]; enum iofields blocknr; size_t bytes; #ifdef HAVE_HDF5 int rank, pcsum; hid_t hdf5_file = 0, hdf5_grp[6], hdf5_dataspace_in_file; hid_t hdf5_datatype = 0, hdf5_dataspace_in_memory, hdf5_dataset; hsize_t dims[2], count[2], start[2]; #endif #if defined(COSMIC_RAYS) && (!defined(CR_IC)) int CRpop; #endif #define SKIP {my_fread(&blksize1,sizeof(int),1,fd);} #define SKIP2 {my_fread(&blksize2,sizeof(int),1,fd);} if(ThisTask == readTask) { if(All.ICFormat == 1 || All.ICFormat == 2) { if(!(fd = fopen(fname, "r"))) { printf("can't open file `%s' for reading initial conditions.\n", fname); endrun(123); } if(All.ICFormat == 2) { SKIP; #ifdef AUTO_SWAP_ENDIAN_READIC swap_file = blksize1; #endif my_fread(&label, sizeof(char), 4, fd); my_fread(&nextblock, sizeof(int), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_Nbyte((char *) &nextblock, 1, 4); #endif printf("Reading header => '%c%c%c%c' (%d byte)\n", label[0], label[1], label[2], label[3], nextblock); SKIP2; } SKIP; #ifdef AUTO_SWAP_ENDIAN_READIC if(All.ICFormat == 1) { if(blksize1 != 256) swap_file = 1; } #endif my_fread(&header, sizeof(header), 1, fd); SKIP2; #ifdef AUTO_SWAP_ENDIAN_READIC swap_Nbyte((char *) &blksize1, 1, 4); swap_Nbyte((char *) &blksize2, 1, 4); #endif if(blksize1 != 256 || blksize2 != 256) { printf("incorrect header format\n"); fflush(stdout); endrun(890); /* Probable error is wrong size of fill[] in header file. Needs to be 256 bytes in total. */ } #ifdef AUTO_SWAP_ENDIAN_READIC swap_header(); #endif } #ifdef HAVE_HDF5 if(All.ICFormat == 3) { read_header_attributes_in_hdf5(fname); hdf5_file = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT); for(type = 0; type < 6; type++) { if(header.npart[type] > 0) { sprintf(buf, "/PartType%d", type); hdf5_grp[type] = H5Gopen(hdf5_file, buf); } } } #endif for(task = readTask + 1; task <= lastTask; task++) { MPI_Ssend(&header, sizeof(header), MPI_BYTE, task, TAG_HEADER, MPI_COMM_WORLD); #ifdef AUTO_SWAP_ENDIAN_READIC MPI_Ssend(&swap_file, sizeof(int), MPI_INT, task, TAG_SWAP, MPI_COMM_WORLD); #endif } } else { MPI_Recv(&header, sizeof(header), MPI_BYTE, readTask, TAG_HEADER, MPI_COMM_WORLD, &status); #ifdef AUTO_SWAP_ENDIAN_READIC MPI_Recv(&swap_file, sizeof(int), MPI_INT, readTask, TAG_SWAP, MPI_COMM_WORLD, &status); #endif } #ifdef INPUT_IN_DOUBLEPRECISION if(header.flag_doubleprecision == 0) { if(ThisTask == 0) printf ("\nProblem: Code compiled with INPUT_IN_DOUBLEPRECISION, but input files are in single precision!\n"); endrun(11); } #else if(header.flag_doubleprecision) { if(ThisTask == 0) printf ("\nProblem: Code not compiled with INPUT_IN_DOUBLEPRECISION, but input files are in double precision!\n"); endrun(10); } #endif if(All.TotNumPart == 0) { if(header.num_files <= 1) for(i = 0; i < 6; i++) { header.npartTotal[i] = header.npart[i]; #ifdef SFR header.npartTotalHighWord[i] = 0; #endif } All.TotN_gas = header.npartTotal[0] + (((long long) header.npartTotalHighWord[0]) << 32); for(i = 0, All.TotNumPart = 0; i < 6; i++) { All.TotNumPart += header.npartTotal[i]; All.TotNumPart += (((long long) header.npartTotalHighWord[i]) << 32); } #ifdef GENERATE_GAS_IN_ICS if(RestartFlag == 0) { All.TotN_gas += header.npartTotal[1]; All.TotNumPart += header.npartTotal[1]; } #endif for(i = 0; i < 6; i++) All.MassTable[i] = header.mass[i]; All.MaxPart = (int) (All.PartAllocFactor * (All.TotNumPart / NTask)); /* sets the maximum number of particles that may */ #ifdef GASRETURN All.MaxPartSph = (int) (All.PartAllocFactor * (All.TotNumPart / NTask)); /* sets the maximum number of particles that may */ #else All.MaxPartSph = (int) (All.PartAllocFactor * (All.TotN_gas / NTask)); /* sets the maximum number of particles that may */ #endif #ifdef INHOMOG_GASDISTR_HINT All.MaxPartSph = All.MaxPart; #endif allocate_memory(); if(!(CommBuffer = mymalloc(bytes = All.BufferSize * 1024 * 1024))) { printf("failed to allocate memory for `CommBuffer' (%g MB).\n", bytes / (1024.0 * 1024.0)); endrun(2); } if(RestartFlag >= 2) All.Time = All.TimeBegin = header.time; } if(ThisTask == readTask) { for(i = 0, n_in_file = 0; i < 6; i++) n_in_file += header.npart[i]; printf("\nreading file `%s' on task=%d (contains %d particles.)\n" "distributing this file to tasks %d-%d\n" "Type 0 (gas): %8d (tot=%6d%09d) masstab=%g\n" "Type 1 (halo): %8d (tot=%6d%09d) masstab=%g\n" "Type 2 (disk): %8d (tot=%6d%09d) masstab=%g\n" "Type 3 (bulge): %8d (tot=%6d%09d) masstab=%g\n" "Type 4 (stars): %8d (tot=%6d%09d) masstab=%g\n" "Type 5 (bndry): %8d (tot=%6d%09d) masstab=%g\n\n", fname, ThisTask, n_in_file, readTask, lastTask, header.npart[0], (int) (header.npartTotal[0] / 1000000000), (int) (header.npartTotal[0] % 1000000000), All.MassTable[0], header.npart[1], (int) (header.npartTotal[1] / 1000000000), (int) (header.npartTotal[1] % 1000000000), All.MassTable[1], header.npart[2], (int) (header.npartTotal[2] / 1000000000), (int) (header.npartTotal[2] % 1000000000), All.MassTable[2], header.npart[3], (int) (header.npartTotal[3] / 1000000000), (int) (header.npartTotal[3] % 1000000000), All.MassTable[3], header.npart[4], (int) (header.npartTotal[4] / 1000000000), (int) (header.npartTotal[4] % 1000000000), All.MassTable[4], header.npart[5], (int) (header.npartTotal[5] / 1000000000), (int) (header.npartTotal[5] % 1000000000), All.MassTable[5]); fflush(stdout); } ntask = lastTask - readTask + 1; /* to collect the gas particles all at the beginning (in case several snapshot files are read on the current CPU) we move the collisionless particles such that a gap of the right size is created */ for(type = 0, nall = 0; type < 6; type++) { n_in_file = header.npart[type]; n_for_this_task = n_in_file / ntask; if((ThisTask - readTask) < (n_in_file % ntask)) n_for_this_task++; if(type == 0) { if(N_gas + n_for_this_task > All.MaxPartSph) { printf("Not enough space on task=%d for SPH particles (space for %d, need at least %d)\n", ThisTask, All.MaxPartSph, N_gas + n_for_this_task); fflush(stdout); endrun(172); } } nall += n_for_this_task; } if(NumPart + nall > All.MaxPart) { printf("Not enough space on task=%d (space for %d, need at least %d)\n", ThisTask, All.MaxPart, NumPart + nall); fflush(stdout); endrun(173); } memmove(&P[N_gas + nall], &P[N_gas], (NumPart - N_gas) * sizeof(struct particle_data)); nstart = N_gas; for(bnr = 0; bnr < 1000; bnr++) { blocknr = (enum iofields) bnr; if(blocknr == IO_LASTENTRY) break; if(blockpresent(blocknr)) { #ifdef CR_IC if(RestartFlag == 0 && ((blocknr > IO_CR_Q0 && blocknr != IO_BFLD) || (blocknr >= IO_RHO && blocknr <= IO_ACCEL))) #else #ifdef EOS_DEGENERATE if(RestartFlag == 0 && (blocknr > IO_U && blocknr != IO_EOSXNUC)) #else #ifndef CHEMISTRY #ifndef READ_HSML /* normal */ if(RestartFlag == 0 && blocknr > IO_U && blocknr != IO_BFLD && blocknr != IO_Z && blocknr != IO_AGE) #else if(RestartFlag == 0 && blocknr > IO_U && blocknr != IO_BFLD && blocknr != IO_HSML) #endif #else if(RestartFlag == 0 && blocknr > IO_HM) #endif #endif #endif #if defined(DISTORTIONTENSORPS) && !defined(COSMIC_DISTORTION) if(RestartFlag == 0 && (blocknr > IO_U && blocknr != IO_SHEET_ORIENTATION)) if(RestartFlag == 0 && (blocknr > IO_U && blocknr != IO_INIT_DENSITY)) if(RestartFlag == 0 && (blocknr > IO_U && blocknr != IO_CAUSTIC_COUNTER)) #ifdef DISTORTION_READALL if(RestartFlag == 0 && (blocknr > IO_U && blocknr != IO_DISTORTIONTENSORPS)) #endif #endif continue; /* ignore all other blocks in initial conditions */ #ifdef BINISET if(RestartFlag == 0 && blocknr == IO_BFLD) continue; #endif if(ThisTask == readTask) { get_dataset_name(blocknr, buf); printf("reading block %d (%s)...\n", blocknr, buf); fflush(stdout); } bytes_per_blockelement = get_bytes_per_blockelement(blocknr, 1); blockmaxlen = ((int) (All.BufferSize * 1024 * 1024)) / bytes_per_blockelement; npart = get_particles_in_block(blocknr, &typelist[0]); if(npart > 0) { if(blocknr != IO_DMHSML && blocknr != IO_DMDENSITY && blocknr != IO_DMVELDISP && blocknr != IO_DMHSML_V && blocknr != IO_DMDENSITY_V) if(ThisTask == readTask) { if(All.ICFormat == 2) { SKIP; my_fread(&label, sizeof(char), 4, fd); my_fread(&nextblock, sizeof(int), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_Nbyte((char *) &nextblock, 1, 4); #endif printf("Reading header => '%c%c%c%c' (%d byte)\n", label[0], label[1], label[2], label[3], nextblock); SKIP2; get_Tab_IO_Label(blocknr, expected_label); if(strncmp(label, expected_label, 4) != 0) { printf("incorrect block-structure!\n"); printf("expected '%c%c%c%c' but found '%c%c%c%c'\n", label[0], label[1], label[2], label[3], expected_label[0], expected_label[1], expected_label[2], expected_label[3]); fflush(stdout); endrun(1890); } } if(All.ICFormat == 1 || All.ICFormat == 2) SKIP; } for(type = 0, offset = 0, nread = 0; type < 6; type++) { n_in_file = header.npart[type]; #ifdef HAVE_HDF5 pcsum = 0; #endif if(typelist[type] == 0) { n_for_this_task = n_in_file / ntask; if((ThisTask - readTask) < (n_in_file % ntask)) n_for_this_task++; offset += n_for_this_task; } else { for(task = readTask; task <= lastTask; task++) { n_for_this_task = n_in_file / ntask; if((task - readTask) < (n_in_file % ntask)) n_for_this_task++; if(task == ThisTask) if(NumPart + n_for_this_task > All.MaxPart) { printf("too many particles. %d %d %d\n", NumPart, n_for_this_task, All.MaxPart); endrun(1313); } do { pc = n_for_this_task; if(pc > blockmaxlen) pc = blockmaxlen; if(ThisTask == readTask) { if(All.ICFormat == 1 || All.ICFormat == 2) { if(blocknr != IO_DMHSML && blocknr != IO_DMDENSITY && blocknr != IO_DMVELDISP && blocknr != IO_DMHSML_V && blocknr != IO_DMDENSITY_V) { my_fread(CommBuffer, bytes_per_blockelement, pc, fd); nread += pc; } else { #ifdef SUBFIND_RESHUFFLE_CATALOGUE read_hsml_files(CommBuffer, pc, blocknr, NumPartPerFile[FileNr] + nread); #endif nread += pc; } } #ifdef HAVE_HDF5 if(All.ICFormat == 3 && pc > 0) { get_dataset_name(blocknr, buf); hdf5_dataset = H5Dopen(hdf5_grp[type], buf); dims[0] = header.npart[type]; dims[1] = get_values_per_blockelement(blocknr); if(dims[1] == 1) rank = 1; else rank = 2; hdf5_dataspace_in_file = H5Screate_simple(rank, dims, NULL); dims[0] = pc; hdf5_dataspace_in_memory = H5Screate_simple(rank, dims, NULL); start[0] = pcsum; start[1] = 0; count[0] = pc; count[1] = get_values_per_blockelement(blocknr); pcsum += pc; H5Sselect_hyperslab(hdf5_dataspace_in_file, H5S_SELECT_SET, start, NULL, count, NULL); switch (get_datatype_in_block(blocknr)) { case 0: hdf5_datatype = H5Tcopy(H5T_NATIVE_UINT); break; case 1: #ifdef INPUT_IN_DOUBLEPRECISION hdf5_datatype = H5Tcopy(H5T_NATIVE_DOUBLE); #else hdf5_datatype = H5Tcopy(H5T_NATIVE_FLOAT); #endif break; case 2: hdf5_datatype = H5Tcopy(H5T_NATIVE_UINT64); break; } H5Dread(hdf5_dataset, hdf5_datatype, hdf5_dataspace_in_memory, hdf5_dataspace_in_file, H5P_DEFAULT, CommBuffer); H5Tclose(hdf5_datatype); H5Sclose(hdf5_dataspace_in_memory); H5Sclose(hdf5_dataspace_in_file); H5Dclose(hdf5_dataset); } #endif } if(ThisTask == readTask && task != readTask && pc > 0) MPI_Ssend(CommBuffer, bytes_per_blockelement * pc, MPI_BYTE, task, TAG_PDATA, MPI_COMM_WORLD); if(ThisTask != readTask && task == ThisTask && pc > 0) MPI_Recv(CommBuffer, bytes_per_blockelement * pc, MPI_BYTE, readTask, TAG_PDATA, MPI_COMM_WORLD, &status); if(ThisTask == task) { empty_read_buffer(blocknr, nstart + offset, pc, type); offset += pc; } n_for_this_task -= pc; } while(n_for_this_task > 0); } } } if(ThisTask == readTask) { if(blocknr != IO_DMHSML && blocknr != IO_DMDENSITY && blocknr != IO_DMVELDISP && blocknr != IO_DMHSML_V && blocknr != IO_DMDENSITY_V) if(All.ICFormat == 1 || All.ICFormat == 2) { SKIP2; #ifdef AUTO_SWAP_ENDIAN_READIC swap_Nbyte((char *) &blksize1, 1, 4); swap_Nbyte((char *) &blksize2, 1, 4); #endif if(blksize1 != blksize2) { printf("incorrect block-sizes detected!\n"); printf("Task=%d blocknr=%d blksize1=%d blksize2=%d\n", ThisTask, blocknr, blksize1, blksize2); if(blocknr == IO_ID) { printf ("Possible mismatch of 32bit and 64bit ID's in IC file and GADGET compilation !\n"); } fflush(stdout); endrun(1889); } } } } } } #ifdef SAVE_HSML_IN_IC_ORDER MyIDType IdCount = 0; for(type = 0, offset = 0; type < 6; type++) { n_in_file = header.npart[type]; for(task = readTask; task <= lastTask; task++) { n_for_this_task = n_in_file / ntask; if((task - readTask) < (n_in_file % ntask)) n_for_this_task++; if(ThisTask == task) { int i; for(i = 0; i < n_for_this_task; i++) P[nstart + offset + i].ID_ic_order = NumPartPerFile[FileNr] + IdCount + i; offset += n_for_this_task; } IdCount += n_for_this_task; } } #endif for(type = 0; type < 6; type++) { n_in_file = header.npart[type]; n_for_this_task = n_in_file / ntask; if((ThisTask - readTask) < (n_in_file % ntask)) n_for_this_task++; NumPart += n_for_this_task; if(type == 0) N_gas += n_for_this_task; } if(ThisTask == readTask) { if(All.ICFormat == 1 || All.ICFormat == 2) fclose(fd); #ifdef HAVE_HDF5 if(All.ICFormat == 3) { for(type = 5; type >= 0; type--) if(header.npart[type] > 0) H5Gclose(hdf5_grp[type]); H5Fclose(hdf5_file); } #endif } #if defined(COSMIC_RAYS) && (!defined(CR_IC)) for(i = 0; i < n_for_this_task; i++) { if(P[i].Type != 0) { break; } for(CRpop = 0; CRpop < NUMCRPOP; CRpop++) { SphP[i].CR_C0[CRpop] = 0.0; SphP[i].CR_q0[CRpop] = 1.0e10; } } #endif }
void get_particle_numbers(char *fname, int num_files) { char buf[1000]; int blksize1, blksize2; char label[4]; int nextblock; int i, j; printf("num_files=%d\n", num_files); for(i = 0; i < num_files; i++) { if(num_files > 1) { sprintf(buf, "%s.%d", fname, i); if(All.ICFormat == 3) sprintf(buf, "%s.%d.hdf5", fname, i); } else { sprintf(buf, "%s", fname); if(All.ICFormat == 3) sprintf(buf, "%s.hdf5", fname); } #define SKIP {my_fread(&blksize1,sizeof(int),1,fd);} #define SKIP2 {my_fread(&blksize2,sizeof(int),1,fd);} if(All.ICFormat == 1 || All.ICFormat == 2) { FILE *fd; if(!(fd = fopen(buf, "r"))) { printf("can't open file `%s' for reading initial conditions.\n", buf); endrun(1239); } if(All.ICFormat == 2) { SKIP; #ifdef AUTO_SWAP_ENDIAN_READIC swap_file = blksize1; #endif my_fread(&label, sizeof(char), 4, fd); my_fread(&nextblock, sizeof(int), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_Nbyte((char *) &nextblock, 1, 4); #endif SKIP2; } SKIP; #ifdef AUTO_SWAP_ENDIAN_READIC if(All.ICFormat == 1) { if(blksize1 != 256) swap_file = 1; } #endif my_fread(&header, sizeof(header), 1, fd); SKIP2; #ifdef AUTO_SWAP_ENDIAN_READIC swap_Nbyte((char *) &blksize1, 1, 4); swap_Nbyte((char *) &blksize2, 1, 4); #endif if(blksize1 != 256 || blksize2 != 256) { printf("incorrect header format\n"); fflush(stdout); endrun(890); } #ifdef AUTO_SWAP_ENDIAN_READIC swap_header(); #endif fclose(fd); } #ifdef HAVE_HDF5 if(All.ICFormat == 3) { read_header_attributes_in_hdf5(buf); } #endif NumPartPerFile[i] = 0; for(j = 0; j < 6; j++) { #if defined(SUBFIND_RESHUFFLE_CATALOGUE) if(((1 << j) & (FOF_PRIMARY_LINK_TYPES))) #endif NumPartPerFile[i] += header.npart[j]; } printf("File=%4d: NumPart= %d\n", i, (int) (NumPartPerFile[i])); } long long n, sum; for(i = 0, sum = 0; i < num_files; i++) { n = NumPartPerFile[i]; NumPartPerFile[i] = sum; sum += n; } }
/*! This function determines on how many files a given snapshot is distributed. */ int find_files(char *fname) { FILE *fd; char buf[200], buf1[200]; int dummy; sprintf(buf, "%s.%d", fname, 0); sprintf(buf1, "%s", fname); if(All.ICFormat == 3) { sprintf(buf, "%s.%d.hdf5", fname, 0); sprintf(buf1, "%s.hdf5", fname); } #ifndef HAVE_HDF5 if(All.ICFormat == 3) { if(ThisTask == 0) printf("Code wasn't compiled with HDF5 support enabled!\n"); endrun(0); } #endif header.num_files = 0; if(ThisTask == 0) { if((fd = fopen(buf, "r"))) { if(All.ICFormat == 1 || All.ICFormat == 2) { if(All.ICFormat == 2) { my_fread(&dummy, sizeof(dummy), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_file = dummy; #endif my_fread(&dummy, sizeof(dummy), 1, fd); my_fread(&dummy, sizeof(dummy), 1, fd); my_fread(&dummy, sizeof(dummy), 1, fd); } my_fread(&dummy, sizeof(dummy), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC if(All.SnapFormat == 1) { if(dummy == 256) swap_file = 8; else swap_file = dummy; } #endif my_fread(&header, sizeof(header), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_header(); #endif my_fread(&dummy, sizeof(dummy), 1, fd); } fclose(fd); #ifdef HAVE_HDF5 if(All.ICFormat == 3) read_header_attributes_in_hdf5(buf); #endif } } #ifdef AUTO_SWAP_ENDIAN_READIC MPI_Bcast(&swap_file, sizeof(int), MPI_INT, 0, MPI_COMM_WORLD); #endif MPI_Bcast(&header, sizeof(header), MPI_BYTE, 0, MPI_COMM_WORLD); if(header.num_files > 0) return header.num_files; if(ThisTask == 0) { if((fd = fopen(buf1, "r"))) { if(All.ICFormat == 1 || All.ICFormat == 2) { if(All.ICFormat == 2) { my_fread(&dummy, sizeof(dummy), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_file = dummy; #endif my_fread(&dummy, sizeof(dummy), 1, fd); my_fread(&dummy, sizeof(dummy), 1, fd); my_fread(&dummy, sizeof(dummy), 1, fd); } my_fread(&dummy, sizeof(dummy), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC if(All.SnapFormat == 1) { if(dummy == 256) swap_file = 8; else swap_file = dummy; } #endif my_fread(&header, sizeof(header), 1, fd); #ifdef AUTO_SWAP_ENDIAN_READIC swap_header(); #endif my_fread(&dummy, sizeof(dummy), 1, fd); } fclose(fd); #ifdef HAVE_HDF5 if(All.ICFormat == 3) read_header_attributes_in_hdf5(buf1); #endif header.num_files = 1; } } #ifdef AUTO_SWAP_ENDIAN_READIC MPI_Bcast(&swap_file, sizeof(int), MPI_INT, 0, MPI_COMM_WORLD); #endif MPI_Bcast(&header, sizeof(header), MPI_BYTE, 0, MPI_COMM_WORLD); if(header.num_files > 0) return header.num_files; if(ThisTask == 0) { printf("\nCan't find initial conditions file."); printf("neither as '%s'\nnor as '%s'\n", buf, buf1); fflush(stdout); } endrun(0); return 0; }
int get_drp(char *scanname, FDATA *fd) { int h, d, swapped=0; SCAN *s = &OnScan; XSCAN *x = &XScan; FILE *fp; string buf; void send_line(); double rta(float); char *GetRAStr(double), *GetDECStr(double); char *GetLongStr(double), *GetLatStr(double); int CheckDataSize(int); fp = fopen(scanname, "r"); if (!fp) { sprintf(buf, "Couldn't find DRP file '%s'.", scanname); send_line(buf); return -1; } #ifdef DEBUG printf("File %s opened.\n", scanname); #endif h = fread((char *)s, 1, HEADER, fp); if (h != HEADER) { sprintf(buf, "Error while reading header of DRP file '%s'.", scanname); send_line(buf); fclose(fp); return -1; } #ifdef DEBUG printf("Header (%d) read.\n", h); printf("NChannel=%d\n", s->NChannel); printf("ScanNo=%d\n", s->ScanNo); printf("SLength=%d\n", s->Slength); #endif if (s->NChannel <= 0 || s->ScanNo < 0) { sprintf(buf, "Strange header: ScanNo=%d, NChan=%d, Slength=%d.", s->ScanNo, s->NChannel, s->Slength); send_line(buf); swapbytes((char *)&(s->NChannel), sizeof(short)); swapbytes((char *)&(s->ScanNo), sizeof(short)); swapbytes((char *)&(s->Slength), sizeof(short)); #ifdef DEBUG printf("Byte swapped values:\n"); printf("NChannel=%d\n", s->NChannel); printf("ScanNo=%d\n", s->ScanNo); printf("SLength=%d\n", s->Slength); #endif sprintf(buf, "Let's try byte swapping: NChannel now becomes %d.", s->NChannel); send_line(buf); if (s->NChannel > 0 && s->ScanNo >= 0 && s->Slength > 0) { /* Let's try byteswapping */ send_line("This looks better. Let's go with swapped bytes."); swapped = 1; swap_header(s); } else { /* Give up on this scan */ send_line("It doesn't look better. Can't read this."); fclose(fp); return -1; } } #ifdef DEBUG printf("Need swapping? (1=yes) %d.\n", swapped); #endif if (CheckDataSize(s->NChannel) < s->NChannel) { sprintf(buf, "Error while allocating memory, NChan=%d.", s->NChannel); send_line(buf); fclose(fp); return -1; } #ifdef DEBUG printf("NChannel=%d.\n", s->NChannel); #endif if (s->Slength != (short)DRPVERSION) { if (s->Slength == HEADER + 2*s->NChannel) { /* old DRP scan, correct position for offsets */ s->Longitude -= s->LMapOff/cos(s->Latitude); s->Latitude -= s->BMapOff; } s->Slength = DRPVERSION; /* indicate DRP version */ sprintf(buf, "Detecting old DRP format in '%s' -- converting.", scanname); send_line(buf); } s->Name[11] = '\0'; s->Project[3] = '\0'; s->Observer[15] = '\0'; s->Program[15] = '\0'; s->Molecule[17] = '\0'; SetCSystemFromDRP(s); if (!fd) { fclose(fp); return 0; } d = fread((char *)s->c, sizeof(float), s->NChannel, fp); if (d != s->NChannel) { sprintf(buf, "Error (%d != %d) while reading data of DRP file '%s'.", d, s->NChannel, scanname); send_line(buf); fclose(fp); return -1; } fclose(fp); if (swapped) swap_data(s); x->NChannel = s->NChannel; DRP2FD(s, x, fd); if (fd->coordType == COORD_TYPE_GAL) { sprintf(buf, "DRP (%s: %s %s %5.1f,%5.1f) scan %d read.\n", fd->sname, GetLongStr(fd->x0), GetLatStr(fd->y0), fd->xoff, fd->yoff, fd->sno); } else { sprintf(buf, "DRP (%s: %s %s %5.1f,%5.1f) scan %d read.\n", fd->sname, GetRAStr(fd->x0), GetDECStr(fd->y0), fd->xoff, fd->yoff, fd->sno); } send_line(buf); return 0; }