#!/usr/bin/env python3 #=============================================================================== # Copyright 2015 NetApp, Inc. All Rights Reserved, # contribution by Jorge Mora # # This program is free software; you can redistribute it and/or modify it under # the terms of the GNU General Public License as published by the Free Software # Foundation; either version 2 of the License, or (at your option) any later # version. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. #=============================================================================== import os import time import errno import ctypes import struct import formatstr import traceback import nfstest_config as c from nfstest.utils import * from packet.nfs.nfs4_const import * from nfstest.test_util import TestUtil from fcntl import fcntl,F_WRLCK,F_SETLK # Module constants __author__ = "Jorge Mora (%s)" % c.NFSTEST_AUTHOR_EMAIL __copyright__ = "Copyright (C) 2015 NetApp, Inc." __license__ = "GPL v2" __version__ = "1.3" USAGE = """%prog --server [options] Space reservation tests ======================= Verify correct functionality of space reservations so applications are able to reserve or unreserve space for a file. The system call fallocate is used to manipulate the allocated disk space for a file, either to preallocate or deallocate it. For filesystems which support the fallocate system call, preallocation is done quickly by allocating blocks and marking them as uninitialized, requiring no I/O to the data blocks. This is much faster than creating a file and filling it with zeros. Basic allocate tests verify the disk space is actually preallocated or reserved for the given range by filling up the device after the allocation and make sure data can be written to the allocated range without any problems. Also, any data written outside the allocated range will fail with NFS4ERR_NOSPC when there is no more space left on the device. On the other hand, deallocating space will give the disk space back so it can be used by either the same file on regions not already preallocated or by different files without the risk of getting a no space error. Performance testing using ALLOCATE versus initializing a file to all zeros is also included. The performance comparison is done with different file sizes. Some tests include testing at the protocol level by taking a packet trace and inspecting the actual packets sent to the server or servers. Negative testing is included whenever possible since some testing cannot be done at the protocol level because the fallocate system call does some error checking of its own and the NFS client won't even send an ALLOCATE or DEALLOCATE operation to the server letting the server deal with the error. Negative tests include trying to allocate an invalid range, having an invalid value for either the offset or the length, trying to allocate or deallocate a region on a file opened as read only or the file is a non-regular file type. Examples: The only required option is --server $ %prog --server 192.168.0.11 Notes: The user id in the local host must have access to run commands as root using the 'sudo' command without the need for a password. Tests which require filling up all the disk space on the mounted device should have exclusive access to the device. Valid only for NFS version 4.2 and above.""" # Test script ID SCRIPT_ID = "ALLOC" ALLOC_TESTS = [ "alloc01", "alloc02", "alloc03", "alloc04", "alloc05", "alloc06", ] DEALLOC_TESTS = [ "dealloc01", "dealloc02", "dealloc03", "dealloc04", "dealloc05", "dealloc06", ] PERF_TESTS = [ "perf01", ] # Include the test groups in the list of test names # so they are displayed in the help TESTNAMES = ["alloc"] + ALLOC_TESTS + ["dealloc"] + DEALLOC_TESTS + PERF_TESTS TESTGROUPS = { "alloc": { "tests": ALLOC_TESTS, "desc": "Run all ALLOCATE tests: ", }, "dealloc": { "tests": DEALLOC_TESTS, "desc": "Run all DEALLOCATE tests: ", }, } def getlock(fd, lock_type, offset=0, length=0): """Get byte range lock on file given by file descriptor""" lockdata = struct.pack('hhllhh', lock_type, 0, offset, length, 0, 0) out = fcntl(fd, F_SETLK, lockdata) return struct.unpack('hhllhh', out) class AllocTest(TestUtil): """AllocTest object AllocTest() -> New test object Usage: x = AllocTest(testnames=['alloc01', 'alloc02', 'alloc03', ...]) # Run all the tests x.run_tests() x.exit() """ def __init__(self, **kwargs): """Constructor Initialize object's private data. """ TestUtil.__init__(self, **kwargs) self.opts.version = "%prog " + __version__ # Set default script options # Tests are valid for NFSv4.2 and beyond self.opts.set_defaults(nfsversion=4.2) # Options specific for this test script # Option self.free_blocks hmsg = "Number of free blocks to use when trying to allocate all " + \ "available space [default: %default]" self.test_opgroup.add_option("--free-blocks", type="int", default=64, help=hmsg) # Option self.perf_fsize hmsg = "Starting file size for the perf01 test [default: %default]" self.test_opgroup.add_option("--perf-fsize", default="1MB", help=hmsg) # Option self.perf_mult hmsg = "File size multiplier for the perf01 test, the tests are " + \ "performed for a file size which is a multiple of the " + \ "previous test file size [default: %default]" self.test_opgroup.add_option("--perf-mult", type="int", default=4, help=hmsg) # Option self.perf_time hmsg = "Run the performance test perf01 until the sub-test for " + \ "the current file size executes for more than this time " + \ "[default: %default]" self.test_opgroup.add_option("--perf-time", type="int", default=15, help=hmsg) self.scan_options() # Convert units self.perf_fsize = formatstr.int_units(self.perf_fsize) # Disable createtraces option but save it first for tests that do not # check the NFS packets to verify the assertion self._createtraces = self.createtraces self.createtraces = False def setup(self, **kwargs): """Setup test environment""" self.umount() self.mount() # Get block size for mounted volume self.statvfs = os.statvfs(self.mtdir) super(AllocTest, self).setup(**kwargs) self.umount() def dprint_freebytes(self): """Display available disk space""" self.dprint('DBG4', "Available disk space %s" % formatstr.str_units(self.get_freebytes())) def verify_fallocate(self, fd, offset, size, **kwargs): """Verify fallocate works as expected fd: Allocate/deallocate disk space for the file referred to by this file handle offset: Starting offset where the allocation or deallocation takes place size: Length of region in file to allocate or deallocate msg: Message appended to assertion [default: ""] smsg: Message appended to file size assertion [default: ""] dmsg: Debug message to display [default: None] absfile: File name to display in default debug message [default: self.absfile] ftype: File type [default: "file"] error: Expected error [default: None] dealloc: Verify deallocate when set to True [default: False] """ msg = kwargs.pop("msg", "") smsg = kwargs.pop("smsg", "") dmsg = kwargs.pop("dmsg", None) absfile = kwargs.pop("absfile", self.absfile) ftype = kwargs.pop("ftype", "file") error = kwargs.pop("error", None) dealloc = kwargs.pop("dealloc", False) err = 0 fmsg = "" if dealloc: mode = SR_DEALLOCATE opstr = "Deallocate" else: mode = SR_ALLOCATE opstr = "Allocate" s_msg = opstr.lower() + smsg if dmsg is None: dmsg = "%s %s %s starting at offset %d with length %d" % (opstr, ftype, absfile, offset, size) # Get the size of file fstat = os.fstat(fd) esize = fstat.st_size self.dprint('DBG3', dmsg) out = self.libc.fallocate(fd, mode, offset, size) if out == -1: err = ctypes.get_errno() errstr = errno.errorcode.get(err,err) fmsg = ", got error [%s] %s" % (errstr, os.strerror(err)) elif error: fmsg = ", but it succeeded" if error is None: # Expecting fallocate to succeed self.test(out == 0, "%s should succeed %s" % (opstr, msg), failmsg=fmsg) if dealloc: tmsg = "File size should not change after %s" % s_msg else: esize = max(esize, offset+size) tmsg = "File size should be correct after %s" % s_msg else: # Expecting fallocate to fail tmsg = "File size should not change after a failed %s" % s_msg errorstr = errno.errorcode.get(error,error) self.test(out == -1 and err == error, "%s should fail with %s %s" % (opstr, errorstr, msg), failmsg=fmsg) if ftype == "file": fstat = os.fstat(fd) tfmsg = ", expecting file size %d and got %d" % (esize, fstat.st_size) self.test(esize == fstat.st_size, tmsg, failmsg=tfmsg) return out def verify_allocate(self, offset, size, **kwargs): """Verify client sends ALLOCATE/DEALLOCATE with correct arguments offset: Starting offset of allocation or deallocation size: Length of region in file to allocate or deallocate stateid: Expected stateid in call [default: self.stateid] status: Expected status in reply [default: NFS4_OK] dealloc: Verify DEALLOCATE when set to True [default: False] """ status = kwargs.pop("status", NFS4_OK) stateid = kwargs.pop("stateid", self.stateid) dealloc = kwargs.pop("dealloc", False) mstatus = nfsstat4.get(status, status) nfsop = OP_DEALLOCATE if dealloc else OP_ALLOCATE opstr = "DEALLOCATE" if dealloc else "ALLOCATE" # Find next ALLOCATE/DEALLOCATE call and reply (pktcall, pktreply) = self.find_nfs_op(nfsop, status=None) self.dprint('DBG7', str(pktcall)) self.dprint('DBG7', str(pktreply)) self.test(pktcall, "%s should be sent to the server" % opstr) if pktcall is None: return allocobj = pktcall.NFSop fmsg = ", expecting 0x%08x but got 0x%08x" % (formatstr.crc32(stateid), formatstr.crc32(allocobj.stateid.other)) self.test(allocobj.stateid == stateid, "%s should be sent with correct stateid" % opstr, failmsg=fmsg) fmsg = ", expecting %d but got %d" % (offset, allocobj.offset) self.test(allocobj.offset == offset, "%s should be sent with correct offset" % opstr, failmsg=fmsg) fmsg = ", expecting %d but got %d" % (size, allocobj.length) self.test(allocobj.length == size, "%s should be sent with correct length" % opstr, failmsg=fmsg) if status == NFS4_OK: msg = "%s should return NFS4_OK" % opstr else: msg = "%s should fail with %s when whole range cannot be guaranteed" % (opstr, mstatus) if pktreply: rstatus = pktreply.nfs.status fmsg = ", expecting %s but got %s" % (mstatus, nfsstat4.get(rstatus, rstatus)) else: rstatus = None fmsg = "" self.test(pktreply and rstatus == status, msg, failmsg=fmsg) def alloc01(self, open_mode, offset=0, size=None, msg="", lock=False, dealloc=False): """Main test to verify ALLOCATE/DEALLOCATE succeeds on files opened as write only or read and write. open_mode: Open mode, either O_WRONLY or O_RDWR offset: Starting offset where the allocation or deallocation will take place [default: 0] size: Length of region in file to allocate or deallocate. [default: --filesize option] msg: String to identify the specific test running and it is appended to the main assertion message [default: ""] lock: Lock file before doing the allocate/deallocate [default: False] dealloc: Run the DEALLOCATE test when set to True [default: False] """ try: fd = None if size is None: # Default size to allocate or deallocate size = self.filesize self.test_info("==== %s test %02d%s" % (self.testname, self.testidx, msg)) self.testidx += 1 self.umount() if open_mode == os.O_RDWR or dealloc: # Mount device to create a new file, this file should already # exist for the test self.mount() if open_mode == os.O_WRONLY: open_str = "writing" o_str = "write only" if dealloc: # Create a new file for deallocate tests self.create_file() else: # Get a new file name self.get_filename() drange = [0, 0] zrange = [offset, size] else: open_str = "read and write" o_str = open_str # Create a new file to have an existing file for the test self.create_file() # No change on current data should be expected on allocate drange = [0, self.filesize] if offset+size > self.filesize: # Allocate range is beyond the end of the file so zero data # should be expected beyond the end of the current file size zrange = [self.filesize, offset+size-self.filesize] else: # Allocate range is fully inside the current file size thus # all data should remained intact -- no zeros zrange = [0, 0] if dealloc: nfsop = OP_DEALLOCATE opstr = "Deallocate" if offset >= self.filesize: # Deallocate range is fully outside the current file size # so all data should remained intact -- no zeros drange = [0, self.filesize] zrange = [0, 0] elif offset+size > self.filesize: # Deallocate range is partially outside the current file # size thus data should remain intact from the start of # the file to the start of the deallocated range and # zero data should be expected starting from offset to # the end of the file -- file size should not change drange = [0, offset] zrange = [offset, self.filesize-offset] else: # Deallocate range is fully inside the current file size # thus zero data should be expected on the entire # deallocated range and all data outside this range should # be left intact drange = [0, offset] if offset+size < self.filesize: drange += [offset+size, self.filesize-offset-size] zrange = [offset, size] else: nfsop = OP_ALLOCATE opstr = "Allocate" self.umount() self.trace_start() self.mount() self.dprint('DBG2', "Open file %s for %s" % (self.absfile, open_str)) fd = os.open(self.absfile, open_mode|os.O_CREAT) if lock: self.dprint('DBG3', "Lock file %s starting at offset %d with length %d" % (self.absfile, offset, size)) getlock(fd, F_WRLCK, offset, size) # Allocate or deallocate test range tmsg = "when the file is opened as %s" % o_str self.verify_fallocate(fd, offset, size, msg=tmsg, smsg=msg, dealloc=dealloc) os.close(fd) fd = None # Verify the contents of the file are correct, data and zero regions self.dprint('DBG2', "Open file %s for reading" % self.absfile) fd = os.open(self.absfile, os.O_RDONLY) if drange[1] > 0: # Read from range where previous file data is expected self.dprint('DBG3', "Read file %s %d @ %d" % (self.absfile, drange[1], drange[0])) os.lseek(fd, drange[0], 0) rdata = os.read(fd, drange[1]) wdata = self.data_pattern(drange[0], drange[1]) if dealloc: tmsg = "Read from file before deallocated range should return the file data" else: tmsg = "Read from allocated range within the previous file size should return the file data" self.test(rdata == wdata, tmsg) if len(drange) > 2 and drange[3] > 0: # Read from second range where previous file data is expected self.dprint('DBG3', "Read file %s %d @ %d" % (self.absfile, drange[3], drange[2])) os.lseek(fd, drange[2], 0) rdata = os.read(fd, drange[3]) wdata = self.data_pattern(drange[2], drange[3]) self.test(rdata == wdata, "Read from file after deallocated range should return the file data") if zrange[1] > 0: # Read from range where zero data is expected self.dprint('DBG3', "Read file %s %d @ %d" % (self.absfile, zrange[1], zrange[0])) os.lseek(fd, zrange[0], 0) rdata = os.read(fd, zrange[1]) wdata = bytes(zrange[1]) if dealloc: tmsg = "Read from deallocated range inside the previous file size should return zeros" else: tmsg = "Read from allocated range outside the previous file size should return zeros" self.test(rdata == wdata, tmsg) except Exception: self.test(False, traceback.format_exc()) finally: if fd: os.close(fd) self.umount() self.trace_stop() try: # Process the packet trace to inspect the NFS packets self.trace_open() self.set_pktlist() # Get the correct state id for the ALLOCATE/DEALLOCATE operation self.get_stateid(self.filename, write=True) # Verify ALLOCATE/DEALLOCATE packet call and reply self.verify_allocate(offset, size, dealloc=dealloc) except Exception: self.test(False, traceback.format_exc()) finally: self.pktt.close() def alloc01_test(self): """Verify ALLOCATE succeeds on files opened as write only""" self.test_group("Verify ALLOCATE succeeds on files opened as write only") blocksize = self.statvfs.f_bsize bsize = int(blocksize/2) self.testidx = 1 self.alloc01(os.O_WRONLY) msg1 = " for a range not starting at the beginning of the file" self.alloc01(os.O_WRONLY, offset=blocksize, size=self.filesize, msg=msg1) msg2 = " for a range starting at a non-aligned block size boundary" self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize+bsize, msg=msg2) msg3 = " for a range ending at a non-aligned block size boundary" self.alloc01(os.O_WRONLY, offset=0, size=blocksize+bsize, msg=msg3) msg4 = " for a range starting and ending at a non-aligned block size boundary" self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize, msg=msg4) if hasattr(self, "deleg_stateid") and self.deleg_stateid is None: # Run tests with byte range locking msg = " (locking file)" self.alloc01(os.O_WRONLY, msg=msg, lock=True) self.alloc01(os.O_WRONLY, offset=blocksize, size=self.filesize, msg=msg1+msg, lock=True) self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize+bsize, msg=msg2+msg, lock=True) self.alloc01(os.O_WRONLY, offset=0, size=blocksize+bsize, msg=msg3+msg, lock=True) self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize, msg=msg4+msg, lock=True) def alloc02_test(self): """Verify ALLOCATE succeeds on files opened as read and write""" self.test_group("Verify ALLOCATE succeeds on files opened as read and write") blocksize = self.statvfs.f_bsize bsize = int(blocksize/2) self.testidx = 1 self.alloc01(os.O_RDWR) msg1 = " for a range not starting at the beginning of the file" self.alloc01(os.O_RDWR, offset=blocksize, size=self.filesize, msg=msg1) msg2 = " for a range starting at a non-aligned block size boundary" self.alloc01(os.O_RDWR, offset=bsize, size=blocksize+bsize, msg=msg2) msg3 = " for a range ending at a non-aligned block size boundary" self.alloc01(os.O_RDWR, offset=0, size=blocksize+bsize, msg=msg3) msg4 = " for a range starting and ending at a non-aligned block size boundary" self.alloc01(os.O_RDWR, offset=bsize, size=blocksize, msg=msg4) msg5 = " when range is fully inside the current file size" self.alloc01(os.O_RDWR, offset=int(self.filesize/4), size=int(self.filesize/2), msg=msg5) msg6 = " when range is partially outside the current file size" self.alloc01(os.O_RDWR, offset=int(self.filesize/2), size=self.filesize, msg=msg6) msg7 = " when range is fully outside the current file size" self.alloc01(os.O_RDWR, offset=self.filesize, size=self.filesize, msg=msg7) if hasattr(self, "deleg_stateid") and self.deleg_stateid is None: # Run tests with byte range locking msg = " (locking file)" self.alloc01(os.O_RDWR, msg=msg, lock=True) self.alloc01(os.O_RDWR, offset=blocksize, size=self.filesize, msg=msg1+msg, lock=True) self.alloc01(os.O_RDWR, offset=bsize, size=blocksize+bsize, msg=msg2+msg, lock=True) self.alloc01(os.O_RDWR, offset=0, size=blocksize+bsize, msg=msg3+msg, lock=True) self.alloc01(os.O_RDWR, offset=bsize, size=blocksize, msg=msg4+msg, lock=True) self.alloc01(os.O_RDWR, offset=int(self.filesize/4), size=int(self.filesize/2), msg=msg5+msg, lock=True) self.alloc01(os.O_RDWR, offset=int(self.filesize/2), size=self.filesize, msg=msg6+msg, lock=True) self.alloc01(os.O_RDWR, offset=self.filesize, size=self.filesize, msg=msg7+msg, lock=True) def alloc03(self, dealloc=False): """Main test to verify ALLOCATE/DEALLOCATE fails on files opened as read only dealloc: Run the DEALLOCATE test when set to True [default: False] """ try: fd = None self.umount() if self._createtraces: # Just capture the packet trace when --createtraces is set self.trace_start() self.mount() # Use an existing file absfile = self.abspath(self.files[0]) self.dprint('DBG2', "Open file %s for reading" % absfile) fd = os.open(absfile, os.O_RDONLY) # Allocate or deallocate test range tmsg = "when the file is opened as read only" self.verify_fallocate(fd, 0, self.filesize, absfile=absfile, msg=tmsg, error=errno.EBADF, dealloc=dealloc) except Exception: self.test(False, traceback.format_exc()) finally: if fd: os.close(fd) self.umount() self.trace_stop() self.trace_open() self.pktt.close() def alloc03_test(self): """Verify ALLOCATE fails on files opened as read only""" self.test_group("Verify ALLOCATE fails on files opened as read only") self.alloc03() def alloc04(self, dealloc=False): """Verify DE/ALLOCATE fails with EINVAL for invalid offset or length dealloc: Run the DEALLOCATE test when set to True [default: False] """ try: fd = None self.umount() if self._createtraces: # Just capture the packet trace when --createtraces is set self.trace_start() self.mount() if dealloc: # Create a new file self.create_file() else: # Get a new file name self.get_filename() self.dprint('DBG2', "Open file %s for writing" % self.absfile) fd = os.open(self.absfile, os.O_WRONLY|os.O_CREAT) # Use an invalid offset tmsg = "when the offset is invalid" self.verify_fallocate(fd, -1, self.filesize, msg=tmsg, error=errno.EINVAL, dealloc=dealloc) # Use an invalid length tmsg = "when the length is invalid" self.verify_fallocate(fd, 0, 0, msg=tmsg, error=errno.EINVAL, dealloc=dealloc) except Exception: self.test(False, traceback.format_exc()) finally: if fd: os.close(fd) self.umount() self.trace_stop() self.trace_open() self.pktt.close() def alloc04_test(self): """Verify ALLOCATE fails with EINVAL for invalid offset or length""" self.test_group("Verify ALLOCATE fails EINVAL for invalid offset or length") self.alloc04() def alloc05(self, dealloc=False): """Verify DE/ALLOCATE fails with ESPIPE when using a named pipe file handle dealloc: Run the DEALLOCATE test when set to True [default: False] """ try: fd = None pid = None self.umount() if self._createtraces: # Just capture the packet trace when --createtraces is set self.trace_start() self.mount() # Get a new file name self.get_filename() self.dprint('DBG3', "Create named pipe %s" % self.absfile) os.mkfifo(self.absfile) # Create another process for reading the named pipe pid = os.fork() if pid == 0: try: fd = os.open(self.absfile, os.O_RDONLY) os.read(fd) os.close(fd) finally: os._exit(0) self.dprint('DBG2', "Open named pipe %s for writing" % self.absfile) fd = os.open(self.absfile, os.O_WRONLY) tmsg = "when using a named pipe file handle" self.verify_fallocate(fd, 0, self.filesize, ftype="named pipe", msg=tmsg, error=errno.ESPIPE, dealloc=dealloc) os.close(fd) fd = None except Exception: self.test(False, traceback.format_exc()) finally: if pid is not None: # Reap the background reading process (pid, out) = os.waitpid(pid, 0) if fd: os.close(fd) self.umount() self.trace_stop() self.trace_open() self.pktt.close() def alloc05_test(self): """Verify ALLOCATE fails with ESPIPE when using a named pipe file handle""" self.test_group("Verify ALLOCATE fails ESPIPE when using a named pipe file handle") self.alloc05() def alloc06(self, msg="", lock=False): """Verify ALLOCATE reserves the disk space msg: String to identify the specific test running and it is appended to the main assertion message [default: ""] lock: Lock file before doing the allocate/deallocate [default: False] """ try: fd = None fd1 = None rmfile = None otherfile = None offset = 0 size = 4*self.filesize free_space = self.free_blocks * self.statvfs.f_bsize self.test_info("==== %s test %02d%s" % (self.testname, self.testidx, msg)) self.testidx += 1 self.umount() self.trace_start() self.mount() # Get a new file name self.get_filename() filename = self.filename testfile = self.absfile self.dprint('DBG2', "Open file %s for writing" % testfile) fd = os.open(testfile, os.O_WRONLY|os.O_CREAT) if lock: self.dprint('DBG3', "Lock file %s starting at offset %d with length %d" % (testfile, offset, size)) out = getlock(fd, F_WRLCK, offset, size) tmsg = "when the file is opened as write only" self.verify_fallocate(fd, offset, size, absfile=testfile, msg=tmsg) self.dprint_freebytes() # Get a new file name self.get_filename() maxfile = self.filename rmfile = self.absfile self.dprint('DBG2', "Open file %s for writing" % rmfile) fd1 = os.open(rmfile, os.O_WRONLY|os.O_CREAT) maxsize = self.get_freebytes() - free_space tmsg = "when allocating the maximum number of blocks left on the device" dmsg = "Allocate file %s with length of %s (available disk space minus %s) " % \ (rmfile, formatstr.str_units(maxsize), formatstr.str_units(free_space)) out = self.verify_fallocate(fd1, 0, maxsize, msg=tmsg, dmsg=dmsg) if out == -1: return self.dprint_freebytes() # Check if space was actually allocated if self.get_freebytes() > free_space: self.test(False, "Space was not actually allocated -- skipping rest of the test") return # Use the rest of the remaining space and a little bit more filesize = self.get_freebytes() + self.filesize try: fmsg = ", expecting ENOSPC but it succeeded" werrno = 0 self.create_file(size=filesize) except OSError as werror: werrno = werror.errno fmsg = ", expecting ENOSPC but got %s" % errno.errorcode.get(werrno, werrno) expr = werrno == errno.ENOSPC self.test(expr, "Write to a different file should fail with ENOSPC when no space is left on the device", failmsg=fmsg) otherfile = self.filename self.dprint_freebytes() tmsg = "when whole range cannot be guaranteed" self.verify_fallocate(fd, offset+size, filesize, absfile=testfile, msg=tmsg, error=errno.ENOSPC) self.dprint_freebytes() try: fmsg = ", expecting ENOSPC but it succeeded" werrno = 0 os.lseek(fd, offset+size, 0) data = self.data_pattern(offset+size, filesize) self.dprint('DBG3', "Write file %s %d@%d" % (testfile, len(data), offset+size)) count = os.write(fd, data) os.fsync(fd) except OSError as werror: werrno = werror.errno fmsg = ", expecting ENOSPC but got %s" % errno.errorcode.get(werrno, werrno) expr = werrno == errno.ENOSPC self.test(expr, "Write outside the allocated region should fail with ENOSPC when no space is left on the device", failmsg=fmsg) self.dprint_freebytes() os.lseek(fd, offset, 0) data = self.data_pattern(offset, size, pattern=b"\x55\xaa") self.dprint('DBG3', "Write file %s %d@%d" % (testfile, len(data), offset)) count = os.write(fd, data) os.fsync(fd) self.test(count > 0, "Write within the allocated region should succeed when no space is left on the device"+msg) self.dprint_freebytes() except Exception: self.test(False, traceback.format_exc()) finally: if fd: try: os.close(fd) except: pass if fd1: os.close(fd1) if rmfile: os.unlink(rmfile) self.umount() self.trace_stop() try: self.set_nfserr_list(nfs4list=[NFS4ERR_NOENT, NFS4ERR_NOSPC]) self.trace_open() self.set_pktlist() # Find OPEN and correct stateid to use for the other file self.get_stateid(maxfile) other_stateid = self.stateid # Find OPEN and correct stateid to use self.pktt.rewind(0) self.get_stateid(filename, noreset=True) save_index = self.pktt.get_index() # Verify ALLOCATE packet call and reply self.verify_allocate(offset, size) # Verify ALLOCATE which allocates the rest of the disk space self.verify_allocate(0, maxsize, stateid=other_stateid) # Verify second ALLOCATE for file self.verify_allocate(offset+size, filesize, status=NFS4ERR_NOSPC) # Rewind packet trace to search for WRITEs in_alloc = True out_alloc = False non_alloc = False in_alloc_cnt = 0 out_alloc_cnt = 0 non_alloc_cnt = 0 while True: self.pktt.rewind(save_index) (pktcall, pktreply) = self.find_nfs_op(OP_WRITE, status=None) if not pktcall: break save_index = pktcall.record.index + 1 writeobj = pktcall.NFSop if writeobj.stateid == self.stateid: # WRITE sent to allocated file if writeobj.offset < offset+size: # WRITE sent to allocated region in_alloc_cnt += 1 if pktreply.nfs.status != NFS4_OK: in_alloc = False else: # WRITE sent to non-allocated region out_alloc_cnt += 1 if pktreply.nfs.status == NFS4ERR_NOSPC: out_alloc = True else: # WRITE sent to non-allocated file non_alloc_cnt += 1 if pktreply.nfs.status == NFS4ERR_NOSPC: non_alloc = True if in_alloc_cnt > 0: self.test(in_alloc, "WRITE within the allocated region should succeed when no space is left on the device") else: self.test(False, "WRITE within the allocated region should be sent") if out_alloc_cnt > 0: self.test(out_alloc, "WRITE outside the allocated region should fail with NFS4ERR_NOSPC when no space is left on the device") else: self.test(False, "WRITE outside the allocated region should be sent") if non_alloc_cnt > 0: self.test(non_alloc, "WRITE sent to non-allocated file should return NFS4ERR_NOSPC when no space is left on the device") else: # No writes found for other file, look for OPEN to check if # it failed on open instead self.pktt.rewind(0) file_str = "NFS.claim.name == '%s'" % otherfile (pktcall, pktreply) = self.find_nfs_op(OP_OPEN, match=file_str, status=None) if pktreply is None: # Could not find OPEN, fail with the write error below status = NFS4_OK else: status = pktreply.NFSop.status if status != NFS4_OK: fmsg = ", expecting NFS4ERR_NOSPC but got %s" % nfsstat4.get(status, status) self.test(status == NFS4ERR_NOSPC, "OPEN sent to non-allocated file should return NFS4ERR_NOSPC", failmsg=fmsg) else: self.test(False, "WRITE to non-allocated file should be sent") except Exception: self.test(False, traceback.format_exc()) finally: self.pktt.close() def alloc06_test(self): """Verify ALLOCATE reserves the disk space""" self.test_group("Verify ALLOCATE reserves the disk space") self.testidx = 1 self.alloc06() if hasattr(self, "deleg_stateid") and self.deleg_stateid is None: # Run tests with byte range locking msg = " (locking file)" self.alloc06(msg=msg, lock=True) def dealloc01_test(self): """Verify DEALLOCATE succeeds on files opened as write only""" self.test_group("Verify DEALLOCATE succeeds on files opened as write only") blocksize = self.statvfs.f_bsize bsize = int(blocksize/2) self.testidx = 1 self.alloc01(os.O_WRONLY, dealloc=True) msg1 = " for a range not starting at the beginning of the file" self.alloc01(os.O_WRONLY, offset=blocksize, size=self.filesize, msg=msg1, dealloc=True) msg2 = " for a range starting at a non-aligned block size boundary" self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize+bsize, msg=msg2, dealloc=True) msg3 = " for a range ending at a non-aligned block size boundary" self.alloc01(os.O_WRONLY, offset=0, size=blocksize+bsize, msg=msg3, dealloc=True) msg4 = " for a range starting and ending at a non-aligned block size boundary" self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize, msg=msg4, dealloc=True) msg5 = " when range is fully inside the current file size" self.alloc01(os.O_WRONLY, offset=int(self.filesize/4), size=int(self.filesize/2), msg=msg5, dealloc=True) msg6 = " when range is partially outside the current file size" self.alloc01(os.O_WRONLY, offset=int(self.filesize/2), size=self.filesize, msg=msg6, dealloc=True) msg7 = " when range is fully outside the current file size" self.alloc01(os.O_WRONLY, offset=self.filesize, size=self.filesize, msg=msg7, dealloc=True) if hasattr(self, "deleg_stateid") and self.deleg_stateid is None: # Run tests with byte range locking msg = " (locking file)" self.alloc01(os.O_WRONLY, msg=msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=blocksize, size=self.filesize, msg=msg1+msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize+bsize, msg=msg2+msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=0, size=blocksize+bsize, msg=msg3+msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=bsize, size=blocksize, msg=msg4+msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=int(self.filesize/4), size=int(self.filesize/2), msg=msg5+msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=int(self.filesize/2), size=self.filesize, msg=msg6+msg, lock=True, dealloc=True) self.alloc01(os.O_WRONLY, offset=self.filesize, size=self.filesize, msg=msg7+msg, lock=True, dealloc=True) def dealloc02_test(self): """Verify DEALLOCATE succeeds on files opened as read and write""" self.test_group("Verify DEALLOCATE succeeds on files opened as read and write") blocksize = self.statvfs.f_bsize bsize = int(blocksize/2) self.testidx = 1 self.alloc01(os.O_RDWR, dealloc=True) msg1 = " for a range not starting at the beginning of the file" self.alloc01(os.O_RDWR, offset=blocksize, size=self.filesize, msg=msg1, dealloc=True) msg2 = " for a range starting at a non-aligned block size boundary" self.alloc01(os.O_RDWR, offset=bsize, size=blocksize+bsize, msg=msg2, dealloc=True) msg3 = " for a range ending at a non-aligned block size boundary" self.alloc01(os.O_RDWR, offset=0, size=blocksize+bsize, msg=msg3, dealloc=True) msg4 = " for a range starting and ending at a non-aligned block size boundary" self.alloc01(os.O_RDWR, offset=bsize, size=blocksize, msg=msg4, dealloc=True) msg5 = " when range is fully inside the current file size" self.alloc01(os.O_RDWR, offset=int(self.filesize/4), size=int(self.filesize/2), msg=msg5, dealloc=True) msg6 = " when range is partially outside the current file size" self.alloc01(os.O_RDWR, offset=int(self.filesize/2), size=self.filesize, msg=msg6, dealloc=True) msg7 = " when range is fully outside the current file size" self.alloc01(os.O_RDWR, offset=self.filesize, size=self.filesize, msg=msg7, dealloc=True) if hasattr(self, "deleg_stateid") and self.deleg_stateid is None: # Run tests with byte range locking msg = " (locking file)" self.alloc01(os.O_RDWR, msg=msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=blocksize, size=self.filesize, msg=msg1+msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=bsize, size=blocksize+bsize, msg=msg2+msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=0, size=blocksize+bsize, msg=msg3+msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=bsize, size=blocksize, msg=msg4+msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=int(self.filesize/4), size=int(self.filesize/2), msg=msg5+msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=int(self.filesize/2), size=self.filesize, msg=msg6+msg, lock=True, dealloc=True) self.alloc01(os.O_RDWR, offset=self.filesize, size=self.filesize, msg=msg7+msg, lock=True, dealloc=True) def dealloc03_test(self): """Verify DEALLOCATE fails on files opened as read only""" self.test_group("Verify DEALLOCATE fails on files opened as read only") self.alloc03(dealloc=True) def dealloc04_test(self): """Verify DEALLOCATE fails with EINVAL for invalid offset or length""" self.test_group("Verify DEALLOCATE fails EINVAL for invalid offset or length") self.alloc04(dealloc=True) def dealloc05_test(self): """Verify DEALLOCATE fails with ESPIPE when using a named pipe file handle""" self.test_group("Verify DEALLOCATE fails ESPIPE when using a named pipe file handle") self.alloc05(dealloc=True) def dealloc06(self, msg="", lock=False): """Verify DEALLOCATE unreserves the disk space msg: String to identify the specific test running and it is appended to the main assertion message [default: ""] lock: Lock file before doing the allocate/deallocate [default: False] """ try: fd = None testfile = None free_space = self.free_blocks * self.statvfs.f_bsize self.test_info("==== %s test %02d%s" % (self.testname, self.testidx, msg)) self.testidx += 1 self.umount() self.trace_start() self.mount() self.dprint_freebytes() # Get a new file name self.get_filename() filename = self.filename testfile = self.absfile self.dprint('DBG2', "Open file %s for writing" % testfile) fd = os.open(testfile, os.O_WRONLY|os.O_CREAT) maxsize = self.get_freebytes() - free_space tmsg = "when allocating the maximum number of blocks left on the device" dmsg = "Allocate file %s with length of %s (available disk space minus %s) " % \ (testfile, formatstr.str_units(maxsize), formatstr.str_units(free_space)) out = self.verify_fallocate(fd, 0, maxsize, absfile=testfile, msg=tmsg, dmsg=dmsg) if out == -1: return self.dprint_freebytes() # Check if space was actually allocated if self.get_freebytes() > free_space: self.test(False, "Space was not actually allocated -- skipping rest of the test") return # Use the rest of the remaining space and a little bit more filesize = 2*self.get_freebytes() + self.filesize # Try creating a file to make sure there is no more disk space try: fmsg = ", expecting ENOSPC but it succeeded" werrno = 0 self.create_file(size=filesize) except OSError as werror: werrno = werror.errno fmsg = ", expecting ENOSPC but got %s" % errno.errorcode.get(werrno, werrno) expr = werrno == errno.ENOSPC self.test(expr, "Write to a different file should fail with ENOSPC when no space is left on the device", failmsg=fmsg) self.dprint_freebytes() offset = 0 size = 4*self.filesize # Free space after deallocate free_space = size - offset strsize = formatstr.str_units(size) if lock: self.dprint('DBG3', "Lock file %s starting at offset %d with length %d" % (testfile, offset, size)) out = getlock(fd, F_WRLCK, offset, size) tmsg = "when no space is left on the device" self.verify_fallocate(fd, offset, size, absfile=testfile, msg=tmsg, dealloc=True) self.dprint_freebytes() try: fmsg = "" werrno = 0 os.lseek(fd, offset, 0) data = self.data_pattern(offset, self.filesize) self.dprint('DBG3', "Write file %s %d@%d" % (testfile, len(data), offset)) count = os.write(fd, data) os.fsync(fd) except OSError as werror: werrno = werror.errno fmsg = ", got error [%s] %s" % (errno.errorcode.get(werrno, werrno), os.strerror(werrno)) self.test(werrno == 0, "Write within the deallocated region should succeed", failmsg=fmsg) self.dprint_freebytes() try: fmsg = "" werrno = 0 self.create_file() except OSError as werror: werrno = werror.errno fmsg = ", got error [%s] %s" % (errno.errorcode.get(werrno, werrno), os.strerror(werrno)) self.test(werrno == 0, "Write to another file should succeed when no space is left on the device after a successful DEALLOCATE"+msg, failmsg=fmsg) self.dprint_freebytes() try: fmsg = ", expecting ENOSPC but it succeeded" werrno = 0 os.lseek(fd, offset+self.filesize, 0) data = self.data_pattern(offset+self.filesize, size) self.dprint('DBG3', "Write file %s %d@%d" % (testfile, len(data), offset+self.filesize)) count = os.write(fd, data) os.fsync(fd) except OSError as werror: werrno = werror.errno fmsg = ", expecting ENOSPC but got %s" % errno.errorcode.get(werrno, werrno) expr = werrno == errno.ENOSPC self.test(expr, "Write within the deallocated region should fail with ENOSPC when no space is left on the device", failmsg=fmsg) self.dprint_freebytes() except Exception: self.test(False, traceback.format_exc()) finally: if fd: try: os.close(fd) except: pass if testfile: os.unlink(testfile) self.umount() self.trace_stop() try: self.set_nfserr_list(nfs4list=[NFS4ERR_NOENT, NFS4ERR_NOSPC]) self.trace_open() self.set_pktlist() # Find OPEN and correct stateid to use self.get_stateid(filename) stateid = self.open_stateid if self.deleg_stateid is None else self.deleg_stateid # Verify ALLOCATE which allocates the rest of the disk space self.verify_allocate(0, maxsize, stateid=stateid) # Verify DEALLOCATE for file self.verify_allocate(offset, size, dealloc=True) in_dealloc = True out_dealloc = False non_dealloc = False in_dealloc_cnt = 0 out_dealloc_cnt = 0 non_dealloc_cnt = 0 save_index = self.pktt.get_index() while True: self.pktt.rewind(save_index) (pktcall, pktreply) = self.find_nfs_op(OP_WRITE, status=None) if not pktcall: break save_index = pktcall.record.index + 1 writeobj = pktcall.NFSop free_space -= writeobj.count if writeobj.stateid == self.stateid: # WRITE sent to deallocated file if writeobj.offset < offset+self.filesize: # WRITE sent to deallocated region when space is available in_dealloc_cnt += 1 if pktreply.nfs.status != NFS4_OK: in_dealloc = False else: # WRITE sent to deallocated region when space is no longer available out_dealloc_cnt += 1 if pktreply.nfs.status == NFS4ERR_NOSPC: out_dealloc = True else: # WRITE sent to different file non_dealloc_cnt += 1 if pktreply.nfs.status == NFS4_OK: non_dealloc = True if in_dealloc_cnt > 0: self.test(in_dealloc, "WRITE within the deallocated region should succeed") else: self.test(False, "WRITE within the deallocated region should be sent") if non_dealloc_cnt > 0: self.test(non_dealloc, "WRITE sent to another file should succeed when no space is left on the device after a successful DEALLOCATE") else: self.test(False, "WRITE should be sent to another file when no space is left on the device after a successful DEALLOCATE") if out_dealloc_cnt > 0: self.test(out_dealloc, "WRITE within the deallocated region should fail with NFS4ERR_NOSPC when no space is left on the device") else: self.test(False, "WRITE within the deallocated region should be sent") except Exception: self.test(False, traceback.format_exc()) finally: self.pktt.close() def dealloc06_test(self): """Verify DEALLOCATE unreserves the disk space""" self.test_group("Verify DEALLOCATE unreserves the disk space") self.testidx = 1 self.dealloc06() if hasattr(self, "deleg_stateid") and self.deleg_stateid is None: # Run tests with byte range locking msg = " (locking file)" self.dealloc06(msg=msg, lock=True) def perftest(self, filesize): try: fd = None block_size = 16 * self.statvfs.f_bsize strsize = formatstr.str_units(filesize) filelist = [] # Get a new file name self.get_filename() filelist.append(self.absfile) self.dprint('DBG2', "Open file %s for writing" % self.absfile) fd = os.open(self.absfile, os.O_WRONLY|os.O_CREAT) tstart = time.time() tmsg = "when the file is opened as write only" out = self.verify_fallocate(fd, 0, filesize, msg=tmsg) os.close(fd) fd = None t1delta = time.time() - tstart self.dprint('INFO', "ALLOCATE took %f seconds" % t1delta) # Get a new file name self.get_filename() filelist.append(self.absfile) self.dprint('DBG2', "Open file %s for writing" % self.absfile) fd = os.open(self.absfile, os.O_WRONLY|os.O_CREAT) self.dprint('DBG3', "Initialize file %s with zeros" % self.absfile) size = filesize data = bytes(block_size) tstart = time.time() while size > 0: if block_size > size: data = data[:size] count = os.write(fd, data) size -= count os.close(fd) fd = None t2delta = time.time() - tstart fstat = os.stat(self.absfile) self.test(fstat.st_size == filesize, "File size should be correct after initialization") self.dprint('INFO', "Initialization took %f seconds" % t2delta) if t1delta > 0: perf = int(100.0*(t2delta-t1delta) / t1delta) msg = ", performance improvement for a %s file: %s%%" % (strsize, "{:,}".format(perf)) else: msg = "" self.test(t1delta < t2delta, "ALLOCATE should outperform initializing the file to all zeros" + msg) except Exception: self.test(False, traceback.format_exc()) finally: if fd: os.close(fd) for absfile in filelist: try: if os.path.exists(absfile): self.dprint('DBG5', "Removing file %s" % absfile) os.unlink(absfile) except: pass def perf01_test(self): """Verify ALLOCATE outperforms initializing the file to all zeros""" self.test_group("Verify ALLOCATE outperforms initializing the file to all zeros") # Starting file size filesize = self.perf_fsize self.umount() self.mount() self.testidx = 1 while True: self.test_info("==== %s test %02d" % (self.testname, self.testidx)) self.testidx += 1 tstart = time.time() self.perftest(filesize) tdelta = time.time() - tstart if tdelta > self.perf_time: break filesize = self.perf_mult*filesize self.umount() ################################################################################ # Entry point x = AllocTest(usage=USAGE, testnames=TESTNAMES, testgroups=TESTGROUPS, sid=SCRIPT_ID) try: x.setup(nfiles=1) # Run all the tests x.run_tests() except Exception: x.test(False, traceback.format_exc()) finally: x.cleanup() x.exit()