4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2013, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/liblustre/tests/sanity.c
38 * Lustre Light user test program
42 #define _FILE_OFFSET_BITS 64
49 #include <sys/types.h>
59 #include <liblustre.h>
60 #include "test_common.h"
61 #include <lustre/lustreapi.h>
63 #define _npages (2048)
70 extern char *lustre_path;
76 gettimeofday(&start, NULL); \
77 sprintf(buf, "===== START %s: %s %ld", __FUNCTION__, \
78 (str), (long)start.tv_sec); \
81 memset(buf+len, '=', 100-len); \
90 struct timeval stop; \
91 char buf[100] = { '\0' }; \
92 int len = sizeof(buf) - 1; \
94 gettimeofday(&stop, NULL); \
95 usec = (stop.tv_sec - start.tv_sec) * 1000000 + \
96 (stop.tv_usec - start.tv_usec); \
97 len = snprintf(buf, len, \
98 "===== END TEST %s: successfully (%gs)", \
99 __FUNCTION__, (double)usec / 1000000); \
101 memset(buf+len, '=', sizeof(buf) - len); \
109 #define MAX_PATH_LENGTH 4096
113 char path[MAX_PATH_LENGTH] = "";
115 ENTER("touch+unlink");
116 snprintf(path, MAX_PATH_LENGTH, "%s/test_t1", lustre_path);
119 printf("touch+unlink %s\n", path);
128 char path[MAX_PATH_LENGTH] = "";
130 ENTER("mkdir/rmdir");
131 snprintf(path, MAX_PATH_LENGTH, "%s/test_t2", lustre_path);
140 char path[MAX_PATH_LENGTH] = "";
142 ENTER("regular stat");
143 snprintf(path, MAX_PATH_LENGTH, "%s/test_t3", lustre_path);
146 t_check_stat(path, NULL);
153 char path[MAX_PATH_LENGTH] = "";
156 snprintf(path, MAX_PATH_LENGTH, "%s/test_t4", lustre_path);
159 t_check_stat(path, NULL);
166 char path[MAX_PATH_LENGTH] = "";
167 char path2[MAX_PATH_LENGTH] = "";
170 snprintf(path, MAX_PATH_LENGTH, "%s/test_t6", lustre_path);
171 snprintf(path2, MAX_PATH_LENGTH, "%s/test_t6_link", lustre_path);
174 t_symlink(path, path2);
175 t_check_stat(path2, NULL);
183 char path[MAX_PATH_LENGTH] = "";
184 char path2[MAX_PATH_LENGTH] = "";
185 char cwd[MAX_PATH_LENGTH] = "";
189 ENTER("symlink + chdir and open");
190 snprintf(path, MAX_PATH_LENGTH, "%s/test_t6b", lustre_path);
191 snprintf(path2, MAX_PATH_LENGTH, "%s/test_t6b_link", lustre_path);
194 t_symlink(path, path2);
195 t_check_stat(path2, NULL);
197 tmp = getcwd(cwd, MAX_PATH_LENGTH);
199 fprintf(stderr, "current path too long to fit in "
200 "MAX_PATH_LENGTH?\n");
218 char path[MAX_PATH_LENGTH] = "";
222 snprintf(path, MAX_PATH_LENGTH, "%s/test_t7", lustre_path);
224 if (geteuid() != 0) {
225 rc = mknod(path, S_IFCHR | 0644, (5<<8 | 4));
226 if (rc != -1 || errno != EPERM) {
227 printf("mknod shouldn't success: rc %d, errno %d\n",
231 t_mknod(path, S_IFCHR | 0644, 5, 4);
232 t_check_stat(path, NULL);
240 char path[MAX_PATH_LENGTH] = "";
243 snprintf(path, MAX_PATH_LENGTH, "%s/test_t8", lustre_path);
247 t_chmod_raw(path, 0700);
248 t_check_stat(path, NULL);
253 t_chmod_raw(path, 0700);
254 t_check_stat(path, NULL);
262 char path[MAX_PATH_LENGTH] = "";
263 char path2[MAX_PATH_LENGTH] = "";
266 snprintf(path, MAX_PATH_LENGTH, "%s/test_t9", lustre_path);
267 snprintf(path2, MAX_PATH_LENGTH, "%s/test_t9_link", lustre_path);
271 t_check_stat(path, NULL);
272 t_check_stat(path2, NULL);
280 char dir1[MAX_PATH_LENGTH] = "";
281 char dir2[MAX_PATH_LENGTH] = "";
282 char path1[MAX_PATH_LENGTH] = "";
283 char path2[MAX_PATH_LENGTH] = "";
284 char rename1[MAX_PATH_LENGTH] = "";
285 char rename2[MAX_PATH_LENGTH] = "";
286 char rename3[MAX_PATH_LENGTH] = "";
289 snprintf(dir1, MAX_PATH_LENGTH, "%s/test_t10_dir1", lustre_path);
290 snprintf(dir2, MAX_PATH_LENGTH, "%s/test_t10_dir2", lustre_path);
291 snprintf(path1, MAX_PATH_LENGTH, "%s/test_t10_reg1", lustre_path);
292 snprintf(path2, MAX_PATH_LENGTH, "%s/test_t10_reg2", lustre_path);
293 snprintf(rename1, MAX_PATH_LENGTH, "%s/test_t10_dir1/rename1", lustre_path);
294 snprintf(rename2, MAX_PATH_LENGTH, "%s/test_t10_dir2/rename2", lustre_path);
295 snprintf(rename3, MAX_PATH_LENGTH, "%s/test_t10_dir2/rename3", lustre_path);
301 t_rename(path1, rename1);
302 t_rename(path2, rename2);
303 t_rename(rename1, rename2);
304 t_rename(dir1, rename3);
313 char *base=lustre_path;
314 char path[MAX_PATH_LENGTH], path2[MAX_PATH_LENGTH];
315 int i, j, level = 5, nreg = 5;
318 safe_strncpy(path, base, MAX_PATH_LENGTH);
320 for (i = 0; i < level; i++) {
321 for (j = 0; j < nreg; j++) {
322 sprintf(path2, "%s/file%d", path, j);
326 strcat(path, "/dir");
330 for (i = level; i > 0; i--) {
331 safe_strncpy(path, base, MAX_PATH_LENGTH);
332 for (j = 1; j < i; j++)
333 strcat(path, "/dir");
335 for (j = 0; j < nreg; j++) {
336 sprintf(path2, "%s/file%d", path, j);
340 strcat(path, "/dir");
349 char dir[MAX_PATH_LENGTH] = "";
352 ENTER("empty directory readdir");
353 snprintf(dir, MAX_PATH_LENGTH, "%s/test_t12_dir", lustre_path);
357 t_ls(fd, buf, sizeof(buf));
365 char dir[MAX_PATH_LENGTH] = "";
368 const int nfiles = 20;
369 char *prefix = "test13_filename_prefix_";
371 ENTER("multiple entries directory readdir");
372 snprintf(dir, MAX_PATH_LENGTH, "%s/test_t13_dir/", lustre_path);
375 printf("Creating %d files...\n", nfiles);
376 for (i = 0; i < nfiles; i++) {
377 sprintf(path, "%s%s%05d", dir, prefix, i);
381 t_ls(fd, buf, sizeof(buf));
383 printf("Cleanup...\n");
384 for (i = 0; i < nfiles; i++) {
385 sprintf(path, "%s%s%05d", dir, prefix, i);
394 char dir[MAX_PATH_LENGTH] = "";
397 const int nfiles = 256;
398 char *prefix = "test14_filename_long_prefix_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA___";
399 struct dirent64 *ent;
400 int fd, i, rc, pos, index;
402 ENTER(">1 block(4k) directory readdir");
403 snprintf(dir, MAX_PATH_LENGTH, "%s/test_t14_dir/", lustre_path);
405 rc = mkdir(dir, 0755);
406 if (rc < 0 && errno != EEXIST) {
407 printf("mkdir(%s) error: %s\n", dir, strerror(errno));
410 printf("Creating %d files...\n", nfiles);
411 for (i = 0; i < nfiles; i++) {
412 sprintf(path, "%s%s%05d", dir, prefix, i);
416 printf("Listing...\n");
418 while ((rc = getdirentries64(fd, buf, 1024, &base)) > 0) {
423 ent = (void *) buf + pos;
424 item = (char *) ent->d_name;
425 if (!strcmp(item, ".") || !strcmp(item, ".."))
427 if (strstr(item, prefix) != item) {
428 printf("found bad name %s\n", item);
431 printf("[%03d]: %s\t",
432 index++, item + strlen(prefix));
434 pos += ent->d_reclen;
439 printf("getdents error %d\n", rc);
442 if (index != nfiles) {
443 printf("get %d files != %d\n", index, nfiles);
447 printf("Cleanup...\n");
448 for (i = 0; i < nfiles; i++) {
449 sprintf(path, "%s%s%05d", dir, prefix, i);
458 char file[MAX_PATH_LENGTH] = "";
460 ENTER("open-stat-close");
461 snprintf(file, MAX_PATH_LENGTH, "%s/test_t15_file", lustre_path);
465 t_check_stat(file, NULL);
473 char file[MAX_PATH_LENGTH] = "";
474 ENTER("small-write-read");
475 snprintf(file, MAX_PATH_LENGTH, "%s/test_t16_file", lustre_path);
477 t_echo_create(file, "aaaaaaaaaaaaaaaaaaaaaa");
478 t_grep(file, "aaaaaaaaaaaaaaaaaaaaaa");
485 char file[MAX_PATH_LENGTH] = "";
487 ENTER("open-unlink without close");
488 snprintf(file, MAX_PATH_LENGTH, "%s/test_t17_file", lustre_path);
490 fd = open(file, O_WRONLY | O_CREAT, 0666);
492 printf("failed to create file: %s\n", strerror(errno));
501 char file[MAX_PATH_LENGTH] = "";
504 struct stat statbuf[3];
505 ENTER("write should change mtime/ctime");
506 snprintf(file, MAX_PATH_LENGTH, "%s/test_t18_file", lustre_path);
508 for (i = 0; i < 3; i++) {
509 fd = open(file, O_RDWR|O_CREAT|O_APPEND, (mode_t)0666);
511 printf("error open file: %s\n", strerror(errno));
514 if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
515 printf("error write file\n");
519 if(stat(file, &statbuf[i]) != 0) {
520 printf("Error stat\n");
523 printf("ctime %lu, mtime %lu\n",
524 statbuf[i].st_ctime, statbuf[i].st_mtime);
528 for (i = 1; i < 3; i++) {
529 if ((statbuf[i].st_ctime <= statbuf[i-1].st_ctime) ||
530 (statbuf[i].st_mtime <= statbuf[i-1].st_mtime)) {
531 printf("time error\n");
541 char file[MAX_PATH_LENGTH] = "";
543 struct stat statbuf[3];
544 ENTER("utime should change mtime/atime/ctime");
545 snprintf(file, MAX_PATH_LENGTH, "%s/test_t18b_file", lustre_path);
548 for (i = 0; i < 3; i++) {
550 if(stat(file, &statbuf[i]) != 0) {
551 printf("Error stat\n");
554 printf("atime %lu, mtime %lu, ctime %lu\n",
555 statbuf[i].st_atime, statbuf[i].st_mtime,
556 statbuf[i].st_ctime);
560 for (i = 1; i < 3; i++) {
561 if ((statbuf[i].st_atime <= statbuf[i-1].st_atime) ||
562 (statbuf[i].st_mtime <= statbuf[i-1].st_mtime) ||
563 (statbuf[i].st_ctime <= statbuf[i-1].st_ctime)) {
564 printf("time error\n");
572 static int check_file_size(char *file, long long size)
576 if (stat(file, &statbuf) != 0) {
577 printf("Error stat(%s)\n", file);
580 if (statbuf.st_size != size) {
581 printf("size of %s: %lld != %lld\n", file,
582 (long long)statbuf.st_size, (long long )size);
590 char file[MAX_PATH_LENGTH] = "";
593 ENTER("open(O_TRUNC) should truncate file to 0-length");
594 snprintf(file, MAX_PATH_LENGTH, "%s/test_t19_file", lustre_path);
596 t_echo_create(file, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
598 fd = open(file, O_RDWR|O_CREAT|O_TRUNC, (mode_t)0666);
600 printf("error open file: %s\n", strerror(errno));
604 result = check_file_size(file, 0);
613 char file[MAX_PATH_LENGTH] = "";
618 ENTER("trap app's general bad pointer for file i/o");
619 snprintf(file, MAX_PATH_LENGTH, "%s/test_t20_file", lustre_path);
621 fd = open(file, O_RDWR|O_CREAT, (mode_t)0666);
623 printf("error open file: %s\n", strerror(errno));
627 ret = write(fd, NULL, 20);
628 if (ret != -1 || errno != EFAULT) {
629 printf("write 1: ret %lld, errno %d\n", (long long)ret, errno);
632 ret = write(fd, (void *)-1, 20);
633 if (ret != -1 || errno != EFAULT) {
634 printf("write 2: ret %lld, errno %d\n", (long long)ret, errno);
637 iov[0].iov_base = NULL;
639 iov[1].iov_base = (void *)-1;
641 ret = writev(fd, iov, 2);
642 if (ret != -1 || errno != EFAULT) {
643 printf("writev 1: ret %lld, errno %d\n", (long long)ret, errno);
646 iov[0].iov_base = NULL;
648 iov[1].iov_base = buf;
649 iov[1].iov_len = sizeof(buf);
650 ret = writev(fd, iov, 2);
651 if (ret != sizeof(buf)) {
652 printf("writev 2: ret %lld, error %d\n", (long long)ret, errno);
655 lseek(fd, 0, SEEK_SET);
657 ret = read(fd, NULL, 20);
658 if (ret != -1 || errno != EFAULT) {
659 printf("read 1: ret %lld, errno %d\n", (long long)ret, errno);
662 ret = read(fd, (void *)-1, 20);
663 if (ret != -1 || errno != EFAULT) {
664 printf("read 2: ret %lld, error %d\n", (long long)ret, errno);
667 iov[0].iov_base = NULL;
669 iov[1].iov_base = (void *)-1;
671 ret = readv(fd, iov, 2);
672 if (ret != -1 || errno != EFAULT) {
673 printf("readv 1: ret %lld, error %d\n", (long long)ret, errno);
676 iov[0].iov_base = NULL;
678 iov[1].iov_base = buf;
679 iov[1].iov_len = sizeof(buf);
680 ret = readv(fd, iov, 2);
681 if (ret != sizeof(buf)) {
682 printf("readv 2: ret %lld, error %d\n", (long long)ret, errno);
693 char file[MAX_PATH_LENGTH] = "";
695 struct flock lock = {
697 .l_whence = SEEK_SET,
700 ENTER("basic fcntl support");
701 snprintf(file, MAX_PATH_LENGTH, "%s/test_t21_file", lustre_path);
703 fd = open(file, O_RDWR|O_CREAT, (mode_t)0666);
705 printf("error open file: %s\n", file);
709 t_fcntl(fd, F_SETFL, O_APPEND);
710 ret = t_fcntl(fd, F_GETFL);
711 if ((ret & O_APPEND) == 0) {
712 printf("error get flag: ret %o\n", ret);
716 t_fcntl(fd, F_SETLK, &lock);
717 t_fcntl(fd, F_GETLK, &lock);
718 lock.l_type = F_WRLCK;
719 t_fcntl(fd, F_SETLKW, &lock);
720 t_fcntl(fd, F_GETLK, &lock);
721 lock.l_type = F_UNLCK;
722 t_fcntl(fd, F_SETLK, &lock);
731 char file[MAX_PATH_LENGTH] = "";
733 char *str = "1234567890";
736 ENTER("make sure O_APPEND take effect");
737 snprintf(file, MAX_PATH_LENGTH, "%s/test_t22_file", lustre_path);
739 fd = open(file, O_TRUNC|O_RDWR|O_CREAT|O_APPEND, (mode_t)0666);
741 printf("error open file: %s\n", strerror(errno));
745 lseek(fd, 100, SEEK_SET);
746 ret = write(fd, str, strlen(str));
747 if (ret != strlen(str)) {
748 printf("write 1: ret %lld, errno %d\n", (long long)ret, errno);
752 lseek(fd, 0, SEEK_SET);
753 ret = read(fd, buf, sizeof(buf));
754 if (ret != strlen(str)) {
755 printf("read 1: ret %lld\n", (long long)ret);
759 if (memcmp(buf, str, strlen(str))) {
760 printf("read 1 data err\n");
764 if (fcntl(fd, F_SETFL, 0)) {
765 printf("fcntl err: %s\n", strerror(errno));
769 lseek(fd, 100, SEEK_SET);
770 ret = write(fd, str, strlen(str));
771 if (ret != strlen(str)) {
772 printf("write 2: ret %lld, errno %d\n", (long long)ret, errno);
776 lseek(fd, 100, SEEK_SET);
777 ret = read(fd, buf, sizeof(buf));
778 if (ret != strlen(str)) {
779 printf("read 2: ret %lld\n", (long long)ret);
783 if (memcmp(buf, str, strlen(str))) {
784 printf("read 2 data err\n");
795 char path[MAX_PATH_LENGTH];
800 ENTER("handle seek > 2GB");
801 snprintf(path, MAX_PATH_LENGTH, "%s/f%s", lustre_path, name);
803 fd = open(path, O_WRONLY | O_CREAT | O_LARGEFILE, 0666);
805 printf("failed to create file %s: %s\n", path, strerror(errno));
809 off = 2048ULL * 1024 * 1024 - buf_size / 2;
810 ret = lseek(fd, off, SEEK_SET);
812 printf("seek error for initial %llu != %llu\n",
813 ret, (long long)off);
817 ret = write(fd, buf_alloc, buf_size);
818 if (ret != buf_size) {
819 printf("write error for %d != %llubytes @ %llu\n",
820 buf_size, ret, (long long)off);
826 ret = lseek(fd, off, SEEK_SET);
828 printf("seek < 2GB error for %llu != %llu\n",
829 ret, (long long)off);
831 perror("seek < 2GB");
835 ret = lseek(fd, off + buf_size - 2, SEEK_SET);
836 if (ret != off + buf_size - 2) {
837 printf("seek > 2GB error for %llu != %llu\n",
838 ret, (long long)off);
840 perror("seek > 2GB");
844 ret = lseek(fd, -buf_size + 2, SEEK_CUR);
846 printf("relative seek error for %d %llu != %llu\n",
847 -buf_size + 2, ret, (unsigned long long) off);
849 perror("relative seek");
853 ret = lseek(fd, 0, SEEK_END);
854 if (ret != off + buf_size) {
855 printf("end seek error for %llu != %llu\n",
856 ret, (long long)off + buf_size);
862 ret = lseek(fd, 0, SEEK_SET);
864 printf("seek 0 error for %llu != 0\n", ret);
870 off = 2048ULL * 1024 * 1024, SEEK_SET;
871 ret = lseek(fd, off, SEEK_SET);
873 printf("seek 2GB error for %llu != %llu\n", ret, (unsigned long long) off);
884 /* pos: i/o start from
885 * xfer: npages per transfer
887 static int pages_io(int xfer, loff_t pos)
889 char path[MAX_PATH_LENGTH] = "";
891 int check_sum[_npages] = {0,}, *buf;
892 int fd, rc, i, j, data_error = 0;
893 struct timeval tw1, tw2, tr1, tr2;
897 snprintf(path, MAX_PATH_LENGTH, "%s/test_t50", lustre_path);
899 memset(buf_alloc, 0, buf_size);
901 /* create sample data */
902 for (i = 0, buf = buf_alloc; i < _npages; i++) {
903 for (j = 0; j < PAGE_CACHE_SIZE/sizeof(int); j++, buf++) {
908 /* compute checksum */
909 for (i = 0, buf = buf_alloc; i < _npages; i++) {
910 for (j = 0; j < PAGE_CACHE_SIZE/sizeof(int); j++, buf++) {
911 check_sum[i] += *buf;
921 ret = lseek(fd, pos, SEEK_SET);
923 perror("write seek");
926 gettimeofday(&tw1, NULL);
927 for (i = 0, buf = buf_alloc; i < _npages;
928 i += xfer, buf += xfer * PAGE_CACHE_SIZE / sizeof(int)) {
929 rc = write(fd, buf, PAGE_CACHE_SIZE * xfer);
930 if (rc != PAGE_CACHE_SIZE * xfer) {
931 printf("write error (i %d, rc %d): %s\n", i, rc,
936 gettimeofday(&tw2, NULL);
938 memset(buf_alloc, 0, buf_size);
941 ret = lseek(fd, pos, SEEK_SET);
946 gettimeofday(&tr1, NULL);
947 for (i = 0, buf = buf_alloc; i < _npages;
948 i += xfer, buf += xfer * PAGE_CACHE_SIZE / sizeof(int)) {
949 rc = read(fd, buf, PAGE_CACHE_SIZE * xfer);
950 if (rc != PAGE_CACHE_SIZE * xfer) {
951 printf("read error (i %d, rc %d): %s\n", i, rc,
956 gettimeofday(&tr2, NULL);
958 /* compute checksum */
959 for (i = 0, buf = buf_alloc; i < _npages; i++) {
961 for (j = 0; j < PAGE_CACHE_SIZE/sizeof(int); j++, buf++) {
964 if (sum != check_sum[i]) {
966 printf("chunk %d checksum error expected %#x got %#x\n",
967 i, check_sum[i], sum);
973 tw = (tw2.tv_sec - tw1.tv_sec) * 1000000 + (tw2.tv_usec - tw1.tv_usec);
974 tr = (tr2.tv_sec - tr1.tv_sec) * 1000000 + (tr2.tv_usec - tr1.tv_usec);
975 printf(" (R:%.3fM/s, W:%.3fM/s)\n",
976 (_npages * PAGE_CACHE_SIZE) / (tw / 1000000.0) / (1024 * 1024),
977 (_npages * PAGE_CACHE_SIZE) / (tr / 1000000.0) / (1024 * 1024));
990 ENTER("4k aligned i/o sanity");
991 while (np <= _npages) {
992 printf("%3d per xfer(total %d)...\t", np, _npages);
994 if (pages_io(np, offset) != 0)
1001 int t50b(char *name)
1003 loff_t off_array[] = {1, 17, 255, 258, 4095, 4097, 8191,
1004 1024*1024*1024*1024ULL};
1008 ENTER("4k un-aligned i/o sanity");
1009 for (i = 0; i < sizeof(off_array)/sizeof(loff_t); i++) {
1010 offset = off_array[i];
1011 printf("16 per xfer(total %d), offset %10lld...\t",
1013 if (pages_io(16, offset) != 0)
1026 * truncate(2) checks.
1030 char file[MAX_PATH_LENGTH] = "";
1035 ENTER("truncate() should truncate file to proper length");
1036 snprintf(file, MAX_PATH_LENGTH, "%s/test_t51_file", lustre_path);
1038 for (size = 0; size < T51_NR * T51_STEP; size += T51_STEP) {
1039 t_echo_create(file, "");
1040 if (truncate(file, size) != 0) {
1041 printf("\nerror truncating file: %s\n",strerror(errno));
1044 result = check_file_size(file, size);
1049 t_echo_create(file, "");
1050 fd = open(file, O_RDWR|O_CREAT, (mode_t)0666);
1052 printf("\nerror open file: %s\n", strerror(errno));
1055 if (ftruncate(fd, size) != 0) {
1056 printf("\nerror ftruncating file:%s\n",strerror(errno));
1060 result = check_file_size(file, size);
1064 if (size % (T51_STEP * (T51_NR / 75)) == 0) {
1073 * check atime update during read
1077 char file[MAX_PATH_LENGTH] = "";
1079 struct stat statbuf;
1084 ENTER("atime should be updated during read");
1085 snprintf(file, MAX_PATH_LENGTH, "%s/test_t52_file", lustre_path);
1087 t_echo_create(file, "check atime update during read");
1088 fd = open(file, O_RDONLY);
1090 printf("\nerror open file: %s\n", strerror(errno));
1093 stat(file, &statbuf);
1094 printf("st_atime=%s", ctime(&statbuf.st_atime));
1095 atime = statbuf.st_atime;
1096 for (i = 0; i < 3; i++) {
1099 /* should not ignore read(2)'s return value */
1100 num_read = read(fd, buf, sizeof(buf));
1101 if (num_read < 0 ) {
1102 printf("read from %s: %s\n", file, strerror(errno));
1105 stat(file, &statbuf);
1106 printf("st_atime=%s", ctime(&statbuf.st_atime));
1107 diff = statbuf.st_atime - atime;
1109 printf("atime doesn't updated! failed!\n");
1114 atime = statbuf.st_atime;
1121 #define NEW_TIME 10000
1124 char file[MAX_PATH_LENGTH] = "";
1125 struct utimbuf times; /* struct. buffer for utime() */
1126 struct stat stat_buf; /* struct buffer to hold file info. */
1127 time_t mtime, atime;
1129 ENTER("mtime/atime should be updated by utime() call");
1130 snprintf(file, MAX_PATH_LENGTH, "%s/test_t53_file", lustre_path);
1132 t_echo_create(file, "check mtime/atime update by utime() call");
1134 /* Initialize the modification and access time in the times arg */
1135 times.actime = NEW_TIME+10;
1136 times.modtime = NEW_TIME;
1138 /* file modification/access time */
1139 utime(file, ×);
1141 if (stat(file, &stat_buf) < 0) {
1142 printf("stat(2) of %s failed, error:%d %s\n",
1143 file, errno, strerror(errno));
1145 mtime = stat_buf.st_mtime;
1146 atime = stat_buf.st_atime;
1148 if ((mtime == NEW_TIME) && (atime == NEW_TIME + 10)) {
1153 printf("mod time %ld, expected %ld\n", mtime, (long)NEW_TIME);
1154 printf("acc time %ld, expected %ld\n", atime, (long)NEW_TIME + 10);
1162 char file[MAX_PATH_LENGTH] = "";
1166 ENTER("fcntl should return 0 when succeed in getting flock");
1167 snprintf(file, MAX_PATH_LENGTH, "%s/test_t54_file", lustre_path);
1169 t_echo_create(file, "fcntl should return 0 when succeed");
1171 fd = open(file, O_RDWR);
1173 printf("\nerror open file: %s\n", strerror(errno));
1176 lock.l_type = F_WRLCK;
1180 if ((err = t_fcntl(fd, F_SETLKW, &lock)) != 0) {
1181 fprintf(stderr, "fcntl returned: %d (%s)\n",
1182 err, strerror(err));
1188 lock.l_type = F_UNLCK;
1189 t_fcntl(fd, F_SETLKW, &lock);
1195 /* for O_DIRECTORY */
1200 #define STRIPE_SIZE (2048 * 2048)
1201 #define STRIPE_OFFSET 0
1202 #define STRIPE_COUNT 1
1205 char path[MAX_PATH_LENGTH] = "";
1206 char file[MAX_PATH_LENGTH] = "";
1207 struct lov_user_md *lum = NULL;
1208 struct lov_user_ost_data *lo = NULL;
1209 int index, fd, buflen, rc;
1211 ENTER("setstripe/getstripe");
1212 snprintf(path, MAX_PATH_LENGTH, "%s/test_t55", lustre_path);
1213 snprintf(file, MAX_PATH_LENGTH, "%s/test_t55/file_t55", lustre_path);
1215 buflen = sizeof(struct lov_user_md);
1216 buflen += STRIPE_COUNT * sizeof(struct lov_user_ost_data);
1217 lum = (struct lov_user_md *)malloc(buflen);
1219 printf("out of memory!\n");
1222 memset(lum, 0, buflen);
1225 rc = llapi_file_create(path, STRIPE_SIZE, STRIPE_OFFSET,
1226 STRIPE_COUNT, LOV_PATTERN_RAID0);
1228 printf("llapi_file_create failed: rc = %d (%s) \n",
1235 fd = open(file, O_CREAT | O_RDWR, 0644);
1237 printf("open file(%s) failed: rc = %d (%s) \n)",
1238 file, fd, strerror(errno));
1244 lum->lmm_magic = LOV_USER_MAGIC;
1245 lum->lmm_stripe_count = STRIPE_COUNT;
1246 rc = ioctl(fd, LL_IOC_LOV_GETSTRIPE, lum);
1248 printf("dir:ioctl(LL_IOC_LOV_GETSTRIPE) failed: rc = %d(%s)\n",
1249 rc, strerror(errno));
1260 printf("lmm_magic: 0x%08X\n", lum->lmm_magic);
1261 printf("lmm_object_id: "LPX64"\n",
1262 lmm_oi_id(&lum->lmm_oi));
1263 printf("lmm_object_seq: "LPX64"\n",
1264 lmm_oi_seq(&lum->lmm_oi));
1265 printf("lmm_stripe_count: %u\n", (int)lum->lmm_stripe_count);
1266 printf("lmm_stripe_size: %u\n", lum->lmm_stripe_size);
1267 printf("lmm_stripe_pattern: %x\n", lum->lmm_pattern);
1269 for (index = 0; index < lum->lmm_stripe_count; index++) {
1270 lo = lum->lmm_objects + index;
1271 printf("object %d:\n", index);
1272 printf("\tobject_oid: "DOSTID"\n",
1273 POSTID(&lo->l_ost_oi));
1274 printf("\tost_gen: %#x\n", lo->l_ost_gen);
1275 printf("\tost_idx: %u\n", lo->l_ost_idx);
1279 if (lum->lmm_magic != LOV_USER_MAGIC ||
1280 lum->lmm_pattern != LOV_PATTERN_RAID0 ||
1281 lum->lmm_stripe_size != STRIPE_SIZE ||
1282 lum->lmm_objects[0].l_ost_idx != STRIPE_OFFSET ||
1283 lum->lmm_stripe_count != STRIPE_COUNT) {
1284 printf("incorrect striping information!\n");
1292 /* setstripe on regular file */
1293 rc = llapi_file_create(file, STRIPE_SIZE, STRIPE_OFFSET,
1294 STRIPE_COUNT, LOV_PATTERN_RAID0);
1296 printf("llapi_file_create failed: rc = %d (%s) \n",
1303 fd = open(file, O_RDWR, 0644);
1305 printf("failed to open(%s): rc = %d (%s)\n",
1306 file, fd, strerror(errno));
1313 lum->lmm_magic = LOV_USER_MAGIC;
1314 lum->lmm_stripe_count = STRIPE_COUNT;
1315 rc = ioctl(fd, LL_IOC_LOV_GETSTRIPE, lum);
1317 printf("file:ioctl(LL_IOC_LOV_GETSTRIPE) failed: rc = %d(%s)\n",
1318 rc, strerror(errno));
1328 printf("lmm_magic: 0x%08X\n", lum->lmm_magic);
1329 printf("lmm_object_id: "LPX64"\n",
1330 lmm_oi_id(&lum->lmm_oi));
1331 printf("lmm_object_seq: "LPX64"\n",
1332 lmm_oi_seq(&lum->lmm_oi));
1333 printf("lmm_stripe_count: %u\n", (int)lum->lmm_stripe_count);
1334 printf("lmm_stripe_size: %u\n", lum->lmm_stripe_size);
1335 printf("lmm_stripe_pattern: %x\n", lum->lmm_pattern);
1337 for (index = 0; index < lum->lmm_stripe_count; index++) {
1338 lo = lum->lmm_objects + index;
1339 printf("object %d:\n", index);
1340 printf("\tobject_oid: "DOSTID"\n",
1341 POSTID(&lo->l_ost_oi));
1342 printf("\tost_gen: %#x\n", lo->l_ost_gen);
1343 printf("\tost_idx: %u\n", lo->l_ost_idx);
1347 if (lum->lmm_magic != LOV_USER_MAGIC ||
1348 lum->lmm_pattern != LOV_PATTERN_RAID0 ||
1349 lum->lmm_stripe_size != STRIPE_SIZE ||
1350 lum->lmm_objects[0].l_ost_idx != STRIPE_OFFSET ||
1351 lum->lmm_stripe_count != STRIPE_COUNT) {
1352 printf("incorrect striping information!\n");
1366 * getdirentries should return -1 and set errno to EINVAL when the size
1367 * specified as an argument is too small to contain at least one entry
1368 * (see bugzilla ticket 12229)
1376 struct dirent64 dir;
1378 ENTER("getdirentries should fail if nbytes is too small");
1380 /* Set count to be very small. The result should be EINVAL */
1383 /* open the directory and call getdirentries */
1384 fd = t_opendir(lustre_path);
1386 rc = getdirentries(fd, (char *)&dir, nbytes, &basep);
1389 printf("Test failed: getdirentries returned %lld\n",
1394 if (errno != EINVAL) {
1395 printf("Test failed: getdirentries returned %lld but errno is "
1396 "set to %d (should be EINVAL)\n", (long long)rc, errno);
1405 extern void __liblustre_setup_(void);
1406 extern void __liblustre_cleanup_(void);
1409 void usage(char *cmd)
1412 "usage: %s [-o test][-e test][-v] --target mgsnid:/fsname\n",
1414 printf(" %s --dumpfile dumpfile\n", cmd);
1419 int (*test)(char *name);
1456 int main(int argc, char * const argv[])
1458 struct testlist *test;
1459 int opt_index, c, rc = 0, numonly = 0, numexcept = 0;
1460 char *only[100], *except[100];
1461 static struct option long_opts[] = {
1462 {"dumpfile", 1, 0, 'd'},
1463 {"only", 1, 0, 'o'},
1464 {"except", 1, 0, 'e'},
1465 {"target", 1, 0, 't'},
1466 {"verbose", 1, 0, 'v'},
1470 while ((c = getopt_long(argc, argv, "d:e:o:t:v", long_opts, &opt_index)) != -1) {
1473 setenv(ENV_LUSTRE_DUMPFILE, optarg, 1);
1477 printf("Not running test(s): ");
1478 printf("%s ", optarg);
1479 except[numexcept++] = optarg;
1483 printf("Only running test(s): ");
1484 printf("%s ", optarg);
1485 only[numonly++] = optarg;
1488 setenv(ENV_LUSTRE_MNTTGT, optarg, 1);
1499 if (getenv(ENV_LUSTRE_MNTTGT) == NULL &&
1500 getenv(ENV_LUSTRE_DUMPFILE) == NULL)
1508 __liblustre_setup_();
1510 buf_size = _npages * PAGE_CACHE_SIZE;
1512 printf("allocating %d bytes buffer\n", buf_size);
1513 buf_alloc = calloc(1, buf_size);
1514 if (buf_alloc == NULL) {
1515 fprintf(stderr, "error allocating %d\n", buf_size);
1519 for (test = testlist; test->test != NULL; test++) {
1523 if (numexcept > 0) {
1524 len = strlen(test->name);
1525 for (i = 0; i < numexcept; i++) {
1526 olen = strlen(except[i]);
1531 if (strncmp(except[i], test->name, olen) == 0) {
1532 switch(test->name[olen]) {
1533 case '0': case '1': case '2': case '3':
1534 case '4': case '5': case '6': case '7':
1547 len = strlen(test->name);
1548 for (i = 0; i < numonly; i++) {
1549 olen = strlen(only[i]);
1554 if (strncmp(only[i], test->name, olen) == 0) {
1555 switch(test->name[olen]) {
1556 case '0': case '1': case '2': case '3':
1557 case '4': case '5': case '6': case '7':
1567 if (run && (rc = (test->test)(test->name)) != 0)
1573 printf("liblustre is about to shutdown\n");
1574 __liblustre_cleanup_();
1576 printf("complete successfully\n");