From patchwork Sat Mar 10 18:17:46 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andiry Xu X-Patchwork-Id: 10273817 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 31413605FE for ; Sat, 10 Mar 2018 18:20:32 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 1CE2929759 for ; Sat, 10 Mar 2018 18:20:32 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 083672975F; Sat, 10 Mar 2018 18:20:32 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-1.8 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_NONE,T_DKIM_INVALID autolearn=no version=3.3.1 Received: from ml01.01.org (ml01.01.org [198.145.21.10]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id E3189299D4 for ; Sat, 10 Mar 2018 18:20:29 +0000 (UTC) Received: from [127.0.0.1] (localhost [IPv6:::1]) by ml01.01.org (Postfix) with ESMTP id D125F2258AEE8; Sat, 10 Mar 2018 10:14:04 -0800 (PST) X-Original-To: linux-nvdimm@lists.01.org Delivered-To: linux-nvdimm@lists.01.org Received-SPF: Pass (sender SPF authorized) identity=mailfrom; client-ip=2607:f8b0:400e:c00::241; helo=mail-pf0-x241.google.com; envelope-from=jix024@eng.ucsd.edu; receiver=linux-nvdimm@lists.01.org Received: from mail-pf0-x241.google.com (mail-pf0-x241.google.com [IPv6:2607:f8b0:400e:c00::241]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 0D4212253FB7A for ; Sat, 10 Mar 2018 10:14:02 -0800 (PST) Received: by mail-pf0-x241.google.com with SMTP id d26so2619756pfn.5 for ; Sat, 10 Mar 2018 10:20:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=eng.ucsd.edu; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=lhCHNMckKK4tjr6L481lp3dDRbIiYXThZPaSAxhq0dQ=; b=MTgW94bsmIydpufZsI+X+bgiOhxJqtj4wdXiTWEuaMpMs/BpVFenaAN3lYf4K7K4LY RzLJQ5mTXGQa0YtNmwlc6+htfj7uyLG1iZ7XNbXzDR1LVjOgz5JKnOrF7AS2hZTFrKlA HBoFh7HisGvZW5o3GBJTfG2gx4DWiTCh4TcyU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=lhCHNMckKK4tjr6L481lp3dDRbIiYXThZPaSAxhq0dQ=; b=O4QhHRgvys38y42GVPTUCjmhbfzDChz0s5yxS0QtQHoiydWVGBnhxDZDBzxuzJVqwm CKaFY+8xJO4iIH2lWo3ppMr0gtpHSETZaaZj3EfTn9h8oONIs6XyQ7Qe79ej0i75EU0o k9wjnnCvPPU2DaDUIk2Nqip0LBHyOFIWBUv9JoDzQw2gYABoAFIiUbW/vRwvfE+lvH8i HVU4m8zlPshHlxEWcmfTpwomizGqQe05Rv38vCaCZ55oxhe2f838kOhJGhEeyo3Ex5d0 5XOAy/oLT9mlcKQSFpu2Afzp8gm/MtSshpTBo/F3bK8zZbqx9rCd7qy27YF0p7wCSLmt 4fsg== X-Gm-Message-State: AElRT7HO3d7mW0vLwz9mH2WDQq0edIDbMNsvFERJEt7KeMPKG98g8Rek WrFL279I/Y5A4W51ktWiPBrnsQ== X-Google-Smtp-Source: AG47ELs9SAfPARSwANWVLkKwUD8iorTbdnnFx9Tb+w3SJYWbJ/2hLN6CkD8BgjXQsK+mJG7nfm50pg== X-Received: by 10.98.150.82 with SMTP id c79mr2675452pfe.88.1520706021258; Sat, 10 Mar 2018 10:20:21 -0800 (PST) Received: from brienza-desktop.8.8.4.4 (andxu.ucsd.edu. [132.239.17.134]) by smtp.gmail.com with ESMTPSA id h80sm9210167pfj.181.2018.03.10.10.20.20 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sat, 10 Mar 2018 10:20:20 -0800 (PST) From: Andiry Xu To: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-nvdimm@lists.01.org Subject: [RFC v2 05/83] Add NOVA filesystem definitions and useful helper routines. Date: Sat, 10 Mar 2018 10:17:46 -0800 Message-Id: <1520705944-6723-6-git-send-email-jix024@eng.ucsd.edu> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1520705944-6723-1-git-send-email-jix024@eng.ucsd.edu> References: <1520705944-6723-1-git-send-email-jix024@eng.ucsd.edu> X-BeenThere: linux-nvdimm@lists.01.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: "Linux-nvdimm developer list." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: coughlan@redhat.com, miklos@szeredi.hu, Andiry Xu , david@fromorbit.com, jack@suse.com, swanson@cs.ucsd.edu, swhiteho@redhat.com, andiry.xu@gmail.com MIME-Version: 1.0 Errors-To: linux-nvdimm-bounces@lists.01.org Sender: "Linux-nvdimm" X-Virus-Scanned: ClamAV using ClamSMTP From: Andiry Xu NOVA stores offset rather than absolute addresses in pmem. nova_get_block() and nova_get_addr_off() provide transitions between these two kinds of addresses. Signed-off-by: Andiry Xu --- fs/nova/nova.h | 299 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 299 insertions(+) create mode 100644 fs/nova/nova.h diff --git a/fs/nova/nova.h b/fs/nova/nova.h new file mode 100644 index 0000000..5eb696c --- /dev/null +++ b/fs/nova/nova.h @@ -0,0 +1,299 @@ +/* + * BRIEF DESCRIPTION + * + * Definitions for the NOVA filesystem. + * + * Copyright 2015-2016 Regents of the University of California, + * UCSD Non-Volatile Systems Lab, Andiry Xu + * Copyright 2012-2013 Intel Corporation + * Copyright 2009-2011 Marco Stornelli + * Copyright 2003 Sony Corporation + * Copyright 2003 Matsushita Electric Industrial Co., Ltd. + * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam + * This file is licensed under the terms of the GNU General Public + * License version 2. This program is licensed "as is" without any + * warranty of any kind, whether express or implied. + */ +#ifndef __NOVA_H +#define __NOVA_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "nova_def.h" + +#define PAGE_SHIFT_2M 21 +#define PAGE_SHIFT_1G 30 + + +/* + * Debug code + */ +#ifdef pr_fmt +#undef pr_fmt +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +#endif + +/* #define nova_dbg(s, args...) pr_debug(s, ## args) */ +#define nova_dbg(s, args ...) pr_info(s, ## args) +#define nova_err(sb, s, args ...) nova_error_mng(sb, s, ## args) +#define nova_warn(s, args ...) pr_warn(s, ## args) +#define nova_info(s, args ...) pr_info(s, ## args) + +extern unsigned int nova_dbgmask; +#define NOVA_DBGMASK_MMAPHUGE (0x00000001) +#define NOVA_DBGMASK_MMAP4K (0x00000002) +#define NOVA_DBGMASK_MMAPVERBOSE (0x00000004) +#define NOVA_DBGMASK_MMAPVVERBOSE (0x00000008) +#define NOVA_DBGMASK_VERBOSE (0x00000010) +#define NOVA_DBGMASK_TRANSACTION (0x00000020) + +#define nova_dbg_mmap4k(s, args ...) \ + ((nova_dbgmask & NOVA_DBGMASK_MMAP4K) ? nova_dbg(s, args) : 0) +#define nova_dbg_mmapv(s, args ...) \ + ((nova_dbgmask & NOVA_DBGMASK_MMAPVERBOSE) ? nova_dbg(s, args) : 0) +#define nova_dbg_mmapvv(s, args ...) \ + ((nova_dbgmask & NOVA_DBGMASK_MMAPVVERBOSE) ? nova_dbg(s, args) : 0) + +#define nova_dbg_verbose(s, args ...) \ + ((nova_dbgmask & NOVA_DBGMASK_VERBOSE) ? nova_dbg(s, ##args) : 0) +#define nova_dbgv(s, args ...) nova_dbg_verbose(s, ##args) +#define nova_dbg_trans(s, args ...) \ + ((nova_dbgmask & NOVA_DBGMASK_TRANSACTION) ? nova_dbg(s, ##args) : 0) + +#define NOVA_ASSERT(x) do {\ + if (!(x))\ + nova_warn("assertion failed %s:%d: %s\n", \ + __FILE__, __LINE__, #x);\ + } while (0) + +#define nova_set_bit __test_and_set_bit_le +#define nova_clear_bit __test_and_clear_bit_le +#define nova_find_next_zero_bit find_next_zero_bit_le + +#define clear_opt(o, opt) (o &= ~NOVA_MOUNT_ ## opt) +#define set_opt(o, opt) (o |= NOVA_MOUNT_ ## opt) +#define test_opt(sb, opt) (NOVA_SB(sb)->s_mount_opt & NOVA_MOUNT_ ## opt) + +#define NOVA_LARGE_INODE_TABLE_SIZE (0x200000) +/* NOVA size threshold for using 2M blocks for inode table */ +#define NOVA_LARGE_INODE_TABLE_THREASHOLD (0x20000000) +/* + * nova inode flags + * + * NOVA_EOFBLOCKS_FL There are blocks allocated beyond eof + */ +#define NOVA_EOFBLOCKS_FL 0x20000000 +/* Flags that should be inherited by new inodes from their parent. */ +#define NOVA_FL_INHERITED (FS_SECRM_FL | FS_UNRM_FL | FS_COMPR_FL | \ + FS_SYNC_FL | FS_NODUMP_FL | FS_NOATIME_FL | \ + FS_COMPRBLK_FL | FS_NOCOMP_FL | \ + FS_JOURNAL_DATA_FL | FS_NOTAIL_FL | FS_DIRSYNC_FL) +/* Flags that are appropriate for regular files (all but dir-specific ones). */ +#define NOVA_REG_FLMASK (~(FS_DIRSYNC_FL | FS_TOPDIR_FL)) +/* Flags that are appropriate for non-directories/regular files. */ +#define NOVA_OTHER_FLMASK (FS_NODUMP_FL | FS_NOATIME_FL) +#define NOVA_FL_USER_VISIBLE (FS_FL_USER_VISIBLE | NOVA_EOFBLOCKS_FL) + +/* IOCTLs */ +#define NOVA_PRINT_TIMING 0xBCD00010 +#define NOVA_CLEAR_STATS 0xBCD00011 +#define NOVA_PRINT_LOG 0xBCD00013 +#define NOVA_PRINT_LOG_BLOCKNODE 0xBCD00014 +#define NOVA_PRINT_LOG_PAGES 0xBCD00015 +#define NOVA_PRINT_FREE_LISTS 0xBCD00018 + + +#define READDIR_END (ULONG_MAX) +#define ANY_CPU (65536) +#define FREE_BATCH (16) + +extern unsigned int blk_type_to_shift[NOVA_BLOCK_TYPE_MAX]; +extern unsigned int blk_type_to_size[NOVA_BLOCK_TYPE_MAX]; + + +/* Mask out flags that are inappropriate for the given type of inode. */ +static inline __le32 nova_mask_flags(umode_t mode, __le32 flags) +{ + flags &= cpu_to_le32(NOVA_FL_INHERITED); + if (S_ISDIR(mode)) + return flags; + else if (S_ISREG(mode)) + return flags & cpu_to_le32(NOVA_REG_FLMASK); + else + return flags & cpu_to_le32(NOVA_OTHER_FLMASK); +} + +static inline u32 nova_crc32c(u32 crc, const u8 *data, size_t len) +{ + u8 *ptr = (u8 *) data; + u64 acc = crc; /* accumulator, crc32c value in lower 32b */ + u32 csum; + + /* x86 instruction crc32 is part of SSE-4.2 */ + if (static_cpu_has(X86_FEATURE_XMM4_2)) { + /* This inline assembly implementation should be equivalent + * to the kernel's crc32c_intel_le_hw() function used by + * crc32c(), but this performs better on test machines. + */ + while (len > 8) { + asm volatile(/* 64b quad words */ + "crc32q (%1), %0" + : "=r" (acc) + : "r" (ptr), "0" (acc) + ); + ptr += 8; + len -= 8; + } + + while (len > 0) { + asm volatile(/* trailing bytes */ + "crc32b (%1), %0" + : "=r" (acc) + : "r" (ptr), "0" (acc) + ); + ptr++; + len--; + } + + csum = (u32) acc; + } else { + /* The kernel's crc32c() function should also detect and use the + * crc32 instruction of SSE-4.2. But calling in to this function + * is about 3x to 5x slower than the inline assembly version on + * some test machines. + */ + csum = crc32c(crc, data, len); + } + + return csum; +} + +static inline int memcpy_to_pmem_nocache(void *dst, const void *src, + unsigned int size) +{ + int ret; + + ret = __copy_from_user_inatomic_nocache(dst, src, size); + + return ret; +} + + +/* assumes the length to be 4-byte aligned */ +static inline void memset_nt(void *dest, uint32_t dword, size_t length) +{ + uint64_t dummy1, dummy2; + uint64_t qword = ((uint64_t)dword << 32) | dword; + + asm volatile ("movl %%edx,%%ecx\n" + "andl $63,%%edx\n" + "shrl $6,%%ecx\n" + "jz 9f\n" + "1: movnti %%rax,(%%rdi)\n" + "2: movnti %%rax,1*8(%%rdi)\n" + "3: movnti %%rax,2*8(%%rdi)\n" + "4: movnti %%rax,3*8(%%rdi)\n" + "5: movnti %%rax,4*8(%%rdi)\n" + "8: movnti %%rax,5*8(%%rdi)\n" + "7: movnti %%rax,6*8(%%rdi)\n" + "8: movnti %%rax,7*8(%%rdi)\n" + "leaq 64(%%rdi),%%rdi\n" + "decl %%ecx\n" + "jnz 1b\n" + "9: movl %%edx,%%ecx\n" + "andl $7,%%edx\n" + "shrl $3,%%ecx\n" + "jz 11f\n" + "10: movnti %%rax,(%%rdi)\n" + "leaq 8(%%rdi),%%rdi\n" + "decl %%ecx\n" + "jnz 10b\n" + "11: movl %%edx,%%ecx\n" + "shrl $2,%%ecx\n" + "jz 12f\n" + "movnti %%eax,(%%rdi)\n" + "12:\n" + : "=D"(dummy1), "=d" (dummy2) + : "D" (dest), "a" (qword), "d" (length) + : "memory", "rcx"); +} + + +#include "super.h" // Remove when we factor out these and other functions. + +/* Translate an offset the beginning of the Nova instance to a PMEM address. + * + * If this is part of a read-modify-write of the block, + * nova_memunlock_block() before calling! + */ +static inline void *nova_get_block(struct super_block *sb, u64 block) +{ + struct nova_super_block *ps = nova_get_super(sb); + + return block ? ((void *)ps + block) : NULL; +} + +static inline int nova_get_reference(struct super_block *sb, u64 block, + void *dram, void **nvmm, size_t size) +{ + int rc; + + *nvmm = nova_get_block(sb, block); + rc = memcpy_mcsafe(dram, *nvmm, size); + return rc; +} + + +static inline u64 +nova_get_addr_off(struct nova_sb_info *sbi, void *addr) +{ + NOVA_ASSERT((addr >= sbi->virt_addr) && + (addr < (sbi->virt_addr + sbi->initsize))); + return (u64)(addr - sbi->virt_addr); +} + +static inline u64 +nova_get_block_off(struct super_block *sb, unsigned long blocknr, + unsigned short btype) +{ + return (u64)blocknr << PAGE_SHIFT; +} + + +static inline u64 nova_get_epoch_id(struct super_block *sb) +{ + struct nova_sb_info *sbi = NOVA_SB(sb); + + return sbi->s_epoch_id; +} + +#include "inode.h" +#endif /* __NOVA_H */