1 /* 2 * Copyright (c) International Business Machines Corp., 2012 3 * Copyright (c) Linux Test Project, 2012 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 13 * the GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 20 #define _GNU_SOURCE 21 #include <sys/types.h> 22 #include <sys/uio.h> 23 #include <sys/wait.h> 24 #include <errno.h> 25 #include <limits.h> 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include <time.h> 30 #include <unistd.h> 31 #include <limits.h> 32 33 #include "test.h" 34 #include "safe_macros.h" 35 #include "lapi/syscalls.h" 36 37 char *TCID = "process_vm_readv03"; 38 int TST_TOTAL = 1; 39 40 #define NUM_LOCAL_VECS 4 41 42 static int nflag, sflag; 43 static char *nr_opt, *sz_opt; 44 static option_t options[] = { 45 {"n:", &nflag, &nr_opt}, 46 {"s:", &sflag, &sz_opt}, 47 {NULL, NULL, NULL} 48 }; 49 50 static int nr_iovecs; 51 static long bufsz; 52 static int pipe_fd[2]; 53 static pid_t pids[2]; 54 55 static void gen_random_arr(int *arr, int arr_sz); 56 static void child_alloc(int *bufsz_arr); 57 static void child_invoke(int *bufsz_arr); 58 static long *fetch_remote_addrs(void); 59 static void setup(void); 60 static void cleanup(void); 61 static void help(void); 62 63 int main(int argc, char **argv) 64 { 65 int lc, status; 66 int *bufsz_arr; 67 68 tst_parse_opts(argc, argv, options, &help); 69 70 setup(); 71 for (lc = 0; TEST_LOOPING(lc); lc++) { 72 tst_count = 0; 73 74 SAFE_PIPE(cleanup, pipe_fd); 75 76 bufsz_arr = SAFE_MALLOC(cleanup, nr_iovecs * sizeof(int)); 77 gen_random_arr(bufsz_arr, nr_iovecs); 78 79 /* the start of child_alloc and child_invoke is already 80 * synchronized via pipe */ 81 pids[0] = fork(); 82 switch (pids[0]) { 83 case -1: 84 tst_brkm(TBROK | TERRNO, cleanup, "fork #0"); 85 case 0: 86 child_alloc(bufsz_arr); 87 exit(0); 88 } 89 90 pids[1] = fork(); 91 switch (pids[1]) { 92 case -1: 93 tst_brkm(TBROK | TERRNO, cleanup, "fork #1"); 94 case 0: 95 child_invoke(bufsz_arr); 96 exit(0); 97 } 98 99 /* wait until child_invoke reads from child_alloc's VM */ 100 SAFE_WAITPID(cleanup, pids[1], &status, 0); 101 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) 102 tst_resm(TFAIL, "child 1 returns %d", status); 103 104 /* child_alloc is free to exit now */ 105 TST_SAFE_CHECKPOINT_WAKE(cleanup, 0); 106 107 SAFE_WAITPID(cleanup, pids[0], &status, 0); 108 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) 109 tst_resm(TFAIL, "child 0 returns %d", status); 110 111 free(bufsz_arr); 112 } 113 114 cleanup(); 115 tst_exit(); 116 } 117 118 static void gen_random_arr(int *arr, int arr_sz) 119 { 120 long bufsz_left, bufsz_single; 121 int i; 122 123 bufsz_left = bufsz; 124 for (i = 0; i < arr_sz - 1; i++) { 125 bufsz_single = rand() % (bufsz_left / 2) + 1; 126 arr[i] = bufsz_single; 127 bufsz_left -= bufsz_single; 128 } 129 arr[arr_sz - 1] = bufsz_left; 130 } 131 132 static void child_alloc(int *bufsz_arr) 133 { 134 char **foo; 135 int i, j; 136 char buf[BUFSIZ]; 137 long count; 138 139 foo = SAFE_MALLOC(tst_exit, nr_iovecs * sizeof(char *)); 140 141 count = 0; 142 for (i = 0; i < nr_iovecs; i++) { 143 foo[i] = SAFE_MALLOC(tst_exit, bufsz_arr[i]); 144 for (j = 0; j < bufsz_arr[i]; j++) { 145 foo[i][j] = count % 256; 146 count++; 147 } 148 } 149 tst_resm(TINFO, "child 0: %d iovecs allocated and initialized.", 150 nr_iovecs); 151 152 /* passing addr via pipe */ 153 SAFE_CLOSE(tst_exit, pipe_fd[0]); 154 snprintf(buf, BUFSIZ, "%p", (void *)foo); 155 SAFE_WRITE(tst_exit, 1, pipe_fd[1], buf, strlen(buf) + 1); 156 SAFE_CLOSE(tst_exit, pipe_fd[1]); 157 158 /* wait until child_invoke is done reading from our VM */ 159 TST_SAFE_CHECKPOINT_WAIT(cleanup, 0); 160 } 161 162 static long *fetch_remote_addrs(void) 163 { 164 long *foo, *bar; 165 char buf[BUFSIZ]; 166 long len; 167 struct iovec local, remote; 168 169 /* get addr from pipe */ 170 SAFE_CLOSE(tst_exit, pipe_fd[1]); 171 SAFE_READ(tst_exit, 0, pipe_fd[0], buf, BUFSIZ); 172 SAFE_CLOSE(tst_exit, pipe_fd[0]); 173 if (sscanf(buf, "%p", &foo) != 1) 174 tst_brkm(TBROK | TERRNO, tst_exit, "sscanf"); 175 176 len = nr_iovecs * sizeof(long); 177 bar = SAFE_MALLOC(tst_exit, len); 178 local.iov_base = bar; 179 local.iov_len = len; 180 remote.iov_base = foo; 181 remote.iov_len = len; 182 183 TEST(ltp_syscall(__NR_process_vm_readv, pids[0], &local, 184 1, &remote, 1, 0)); 185 if (TEST_RETURN != len) 186 tst_brkm(TFAIL | TERRNO, tst_exit, "process_vm_readv"); 187 188 return local.iov_base; 189 } 190 191 static void child_invoke(int *bufsz_arr) 192 { 193 int i, j, count, nr_error; 194 unsigned char expect, actual; 195 long *addrs; 196 struct iovec local[NUM_LOCAL_VECS], *remote; 197 int rcv_arr[NUM_LOCAL_VECS]; 198 199 addrs = fetch_remote_addrs(); 200 201 remote = SAFE_MALLOC(tst_exit, nr_iovecs * sizeof(struct iovec)); 202 for (i = 0; i < nr_iovecs; i++) { 203 remote[i].iov_base = (void *)addrs[i]; 204 remote[i].iov_len = bufsz_arr[i]; 205 } 206 tst_resm(TINFO, "child 1: %d remote iovecs received.", nr_iovecs); 207 208 gen_random_arr(rcv_arr, NUM_LOCAL_VECS); 209 for (i = 0; i < NUM_LOCAL_VECS; i++) { 210 local[i].iov_base = SAFE_MALLOC(tst_exit, rcv_arr[i]); 211 local[i].iov_len = rcv_arr[i]; 212 } 213 tst_resm(TINFO, "child 1: %d local iovecs initialized.", 214 NUM_LOCAL_VECS); 215 216 TEST(ltp_syscall(__NR_process_vm_readv, pids[0], local, NUM_LOCAL_VECS, 217 remote, nr_iovecs, 0)); 218 if (TEST_RETURN != bufsz) 219 tst_brkm(TBROK | TERRNO, tst_exit, "process_vm_readv"); 220 221 /* verify every byte */ 222 count = 0; 223 nr_error = 0; 224 for (i = 0; i < NUM_LOCAL_VECS; i++) { 225 for (j = 0; j < local[i].iov_len; j++) { 226 expect = count % 256; 227 actual = ((unsigned char *)local[i].iov_base)[j]; 228 if (expect != actual) { 229 #if DEBUG 230 tst_resm(TFAIL, "child 1: expected %i, got %i " 231 "for byte seq %d", 232 expect, actual, count); 233 #endif 234 nr_error++; 235 } 236 count++; 237 } 238 } 239 if (nr_error) 240 tst_brkm(TFAIL, tst_exit, "child 1: %d incorrect bytes " 241 "received.", nr_error); 242 else 243 tst_resm(TPASS, "child 1: all bytes are correctly received."); 244 } 245 246 static void setup(void) 247 { 248 tst_require_root(); 249 250 /* Just a sanity check of the existence of syscall */ 251 ltp_syscall(__NR_process_vm_readv, getpid(), NULL, 0, NULL, 0, 0); 252 253 nr_iovecs = nflag ? SAFE_STRTOL(NULL, nr_opt, 1, IOV_MAX) : 10; 254 bufsz = sflag ? SAFE_STRTOL(NULL, sz_opt, NUM_LOCAL_VECS, LONG_MAX) 255 : 100000; 256 257 tst_tmpdir(); 258 TST_CHECKPOINT_INIT(cleanup); 259 srand(time(NULL)); 260 261 TEST_PAUSE; 262 } 263 264 static void cleanup(void) 265 { 266 tst_rmdir(); 267 } 268 269 static void help(void) 270 { 271 printf(" -n NUM Set the number of iovecs to be allocated.\n"); 272 printf(" -s NUM Set the size of total buffer size.\n"); 273 } 274
