void host_to_fileio_stat (struct stat *st, struct fio_stat *fst) { LONGEST blksize; host_to_fileio_uint ((long) st->st_dev, fst->fst_dev); host_to_fileio_uint ((long) st->st_ino, fst->fst_ino); host_to_fileio_mode (st->st_mode, fst->fst_mode); host_to_fileio_uint ((long) st->st_nlink, fst->fst_nlink); host_to_fileio_uint ((long) st->st_uid, fst->fst_uid); host_to_fileio_uint ((long) st->st_gid, fst->fst_gid); host_to_fileio_uint ((long) st->st_rdev, fst->fst_rdev); host_to_fileio_ulong ((LONGEST) st->st_size, fst->fst_size); #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE blksize = st->st_blksize; #else blksize = 512; #endif host_to_fileio_ulong (blksize, fst->fst_blksize); #if HAVE_STRUCT_STAT_ST_BLOCKS host_to_fileio_ulong ((LONGEST) st->st_blocks, fst->fst_blocks); #else /* FIXME: This is correct for DJGPP, but other systems that don't have st_blocks, if any, might prefer 512 instead of st_blksize. (eliz, 30-12-2003) */ host_to_fileio_ulong (((LONGEST) st->st_size + blksize - 1) / blksize, fst->fst_blocks); #endif host_to_fileio_time (st->st_atime, fst->fst_atime); host_to_fileio_time (st->st_mtime, fst->fst_mtime); host_to_fileio_time (st->st_ctime, fst->fst_ctime); }
static void remote_fileio_func_fstat (char *buf) { CORE_ADDR ptrval; int fd, ret; long target_fd; LONGEST lnum; struct stat st; struct fio_stat fst; struct timeval tv; /* 1. Parameter: file descriptor */ if (remote_fileio_extract_int (&buf, &target_fd)) { remote_fileio_ioerror (); return; } fd = remote_fileio_map_fd ((int) target_fd); if (fd == FIO_FD_INVALID) { remote_fileio_badfd (); return; } /* 2. Parameter: Ptr to struct stat */ if (remote_fileio_extract_long (&buf, &lnum)) { remote_fileio_ioerror (); return; } ptrval = (CORE_ADDR) lnum; remote_fio_no_longjmp = 1; if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT) { host_to_fileio_uint (1, fst.fst_dev); memset (&st, 0, sizeof (st)); st.st_mode = S_IFCHR | (fd == FIO_FD_CONSOLE_IN ? S_IRUSR : S_IWUSR); st.st_nlink = 1; #ifdef HAVE_GETUID st.st_uid = getuid (); #endif #ifdef HAVE_GETGID st.st_gid = getgid (); #endif #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE st.st_blksize = 512; #endif #if HAVE_STRUCT_STAT_ST_BLOCKS st.st_blocks = 0; #endif if (!gettimeofday (&tv, NULL)) st.st_atime = st.st_mtime = st.st_ctime = tv.tv_sec; else st.st_atime = st.st_mtime = st.st_ctime = (time_t) 0; ret = 0; } else ret = fstat (fd, &st); if (ret == -1) { remote_fileio_return_errno (-1); return; } if (ptrval) { host_to_fileio_stat (&st, &fst); errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst); if (errno != 0) { remote_fileio_return_errno (-1); return; } } remote_fileio_return_success (ret); }
static void remote_fileio_func_stat (char *buf) { CORE_ADDR statptr, nameptr; int ret, namelength; char *pathname; LONGEST lnum; struct stat st; struct fio_stat fst; /* 1. Parameter: Ptr to pathname / length incl. trailing zero */ if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength)) { remote_fileio_ioerror (); return; } /* 2. Parameter: Ptr to struct stat */ if (remote_fileio_extract_long (&buf, &lnum)) { remote_fileio_ioerror (); return; } statptr = (CORE_ADDR) lnum; /* Request pathname using 'm' packet */ pathname = alloca (namelength); if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0) { remote_fileio_ioerror (); return; } remote_fio_no_longjmp = 1; ret = stat (pathname, &st); if (ret == -1) { remote_fileio_return_errno (-1); return; } /* Only operate on regular files and directories. */ if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) { remote_fileio_reply (-1, FILEIO_EACCES); return; } if (statptr) { host_to_fileio_stat (&st, &fst); host_to_fileio_uint (0, fst.fst_dev); errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst); if (errno != 0) { remote_fileio_return_errno (-1); return; } } remote_fileio_return_success (ret); }