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.gnu.org/licenses/gpl-2.0.html
24 * Copyright 2015 Cray Inc, all rights reserved.
27 * A few portions are extracted from llapi_layout_test.c
31 * The CRC32 implementation is from RFC 1952, which bears the
34 * Copyright (c) 1996 L. Peter Deutsch
36 * Permission is granted to copy and distribute this document for any
37 * purpose and without charge, including translations into other
38 * languages and incorporation into compilations, provided that the
39 * copyright notice and this notice are preserved, and that any
40 * substantive changes or deletions from the original are clearly
45 * The purpose of this test is to exert the group lock ioctls in
46 * conjunction with sendfile. Some bugs were found when both were used
47 * at the same time. See LU-6368 and LU-6371.
49 * The program will exit as soon as a non zero error code is returned.
51 * It can be called like this:
53 * dd if=/dev/zero of=/mnt/lustre/foo1 bs=1M count=40
54 * ./sendfile_grouplock /mnt/lustre/foo1
61 #include <sys/types.h>
65 #include <sys/sendfile.h>
67 #include <lustre/lustreapi.h>
68 #include <lustre/lustre_idl.h>
70 #define ERROR(fmt, ...) \
71 fprintf(stderr, "%s: %s:%d: %s: " fmt "\n", \
72 program_invocation_short_name, __FILE__, __LINE__, \
73 __func__, ## __VA_ARGS__);
75 #define DIE(fmt, ...) \
77 ERROR(fmt, ## __VA_ARGS__); \
81 #define ASSERTF(cond, fmt, ...) \
84 DIE("assertion '%s' failed: "fmt, \
85 #cond, ## __VA_ARGS__); \
88 #define PERFORM(testfn) \
90 fprintf(stderr, "Starting test " #testfn " at %lld\n", \
91 (unsigned long long)time(NULL)); \
93 fprintf(stderr, "Finishing test " #testfn " at %lld\n", \
94 (unsigned long long)time(NULL)); \
97 /* This test will copy from source_file to dest_file */
98 static const char *source_file;
99 static char *dest_file;
100 static unsigned long source_crc; /* CRC32 of original file */
103 * A small CRC32 implementation, from RFC 1952
106 /* Table of CRCs of all 8-bit messages. */
107 static unsigned long crc_table[256];
109 /* Flag: has the table been computed? Initially false. */
110 static int crc_table_computed;
112 /* Make the table for a fast CRC. */
113 static void make_crc_table(void)
118 for (n = 0; n < 256; n++) {
119 c = (unsigned long) n;
120 for (k = 0; k < 8; k++) {
122 c = 0xedb88320L ^ (c >> 1);
128 crc_table_computed = 1;
132 * Update a running crc with the bytes buf[0..len-1] and return the
133 * updated crc. The crc should be initialized to zero. Pre- and
134 * post-conditioning (one's complement) is performed within this
135 * function so it shouldn't be done by the caller. Usage example:
137 * unsigned long crc = 0L;
139 * while (read_buffer(buffer, length) != EOF) {
140 * crc = update_crc(crc, buffer, length);
142 * if (crc != original_crc) error();
144 static unsigned long update_crc(unsigned long crc,
145 unsigned char *buf, int len)
147 unsigned long c = crc ^ 0xffffffffL;
150 if (!crc_table_computed)
152 for (n = 0; n < len; n++)
153 c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
155 return c ^ 0xffffffffL;
158 /* Cleanup our test file. */
159 static void cleanup(void)
164 /* Compute the CRC32 of a file */
165 static unsigned long compute_crc(const char *fname)
167 unsigned char buf[1024*1024];
168 unsigned long crc = 0L;
174 fd = open(fname, O_RDONLY);
175 ASSERTF(fd >= 0, "open failed for '%s': %s",
176 fname, strerror(errno));
178 rc = fstat(fd, &stbuf);
179 ASSERTF(rc == 0, "fstat of '%s' failed: %s", fname, strerror(errno));
180 filesize = stbuf.st_size;
182 while (filesize != 0) {
183 size_t to_read = sizeof(buf);
186 if (to_read > filesize)
189 sret = read(fd, buf, to_read);
190 ASSERTF(sret >= 0, "read of %zu bytes from '%s' failed: %s",
191 to_read, fname, strerror(errno));
192 ASSERTF(sret > 0, "unexpected EOF for '%s'",
196 crc = update_crc(crc, buf, sret);
204 /* Helper. Copy a file with sendfile. The destination will be
205 * created. If a group lock is 0, it means do not take one. */
206 static int sendfile_copy(const char *source, int source_gid,
207 const char *dest, int dest_gid)
215 fd_in = open(source, O_RDONLY);
216 ASSERTF(fd_in >= 0, "open failed for '%s': %s",
217 source, strerror(errno));
219 rc = fstat(fd_in, &stbuf);
220 ASSERTF(rc == 0, "fstat of '%s' failed: %s", source, strerror(errno));
221 filesize = stbuf.st_size;
223 if (source_gid != 0) {
224 rc = llapi_group_lock(fd_in, source_gid);
225 ASSERTF(rc == 0, "cannot set group lock %d for '%s': %s",
226 source_gid, source, strerror(-rc));
229 fd_out = open(dest, O_WRONLY | O_TRUNC | O_CREAT, 0644);
230 ASSERTF(fd_out >= 0, "creation failed for '%s': %s",
231 dest, strerror(errno));
234 rc = llapi_group_lock(fd_out, dest_gid);
235 ASSERTF(rc == 0, "cannot set group lock %d for '%s': %s",
236 dest_gid, dest, strerror(-rc));
239 /* Transfer by 10M blocks */
240 while (filesize != 0) {
241 size_t to_copy = 10*1024*1024;
244 if (to_copy > filesize)
247 sret = sendfile(fd_out, fd_in, NULL, to_copy);
250 /* Although senfile can return less than requested,
251 * that should not happen under present conditions. At
252 * the very least, make sure that a decent size was
253 * copied. See LU-6371. */
255 ASSERTF(sret != 0, "sendfile read 0 bytes");
256 ASSERTF(sret > 0, "sendfile failed: %s", strerror(rc));
257 ASSERTF(sret > 100*1024,
258 "sendfile read too little data: %zd bytes", sret);
262 "Warning: sendfile returned %zd bytes instead of %zu requested\n",
275 /* Basic sendfile, without lock taken */
276 static void test10(void)
281 sendfile_copy(source_file, 0, dest_file, 0);
284 crc = compute_crc(dest_file);
285 ASSERTF(source_crc == crc, "CRC differs: %lu and %lu", source_crc, crc);
288 /* sendfile, source locked */
289 static void test11(void)
294 sendfile_copy(source_file, 85543, dest_file, 0);
297 crc = compute_crc(dest_file);
298 ASSERTF(source_crc == crc, "CRC differs: %lu and %lu", source_crc, crc);
301 /* sendfile, destination locked */
302 static void test12(void)
307 sendfile_copy(source_file, 0, dest_file, 98765);
310 crc = compute_crc(dest_file);
311 ASSERTF(source_crc == crc, "CRC differs: %lu and %lu", source_crc, crc);
314 /* sendfile, source and destination locked, with same lock number */
315 static void test13(void)
317 const int gid = 8765;
321 sendfile_copy(source_file, gid, dest_file, gid);
324 crc = compute_crc(dest_file);
325 ASSERTF(source_crc == crc, "CRC differs: %lu and %lu", source_crc, crc);
328 /* sendfile, source and destination locked, with different lock number */
329 static void test14(void)
334 sendfile_copy(source_file, 98765, dest_file, 34543);
337 crc = compute_crc(dest_file);
338 ASSERTF(source_crc == crc, "CRC differs: %lu and %lu", source_crc, crc);
341 /* Basic sendfile, without lock taken, to /dev/null */
342 static void test15(void)
344 sendfile_copy(source_file, 0, "/dev/null", 0);
348 /* sendfile, source locked, to /dev/null */
349 static void test16(void)
351 sendfile_copy(source_file, 85543, "/dev/null", 0);
355 int main(int argc, char *argv[])
359 if (argc != 2 || argv[1][0] != '/') {
361 "Argument must be an absolute path to a Lustre file\n");
365 source_file = argv[1];
366 rc = asprintf(&dest_file, "%s-dest", source_file);
368 fprintf(stderr, "Allocation failure\n");
372 /* Play nice with Lustre test scripts. Non-line buffered output
373 * stream under I/O redirection may appear incorrectly. */
374 setvbuf(stdout, NULL, _IOLBF, 0);
379 /* Compute crc of original file */
380 source_crc = compute_crc(source_file);