License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2007-07-17 11:04:28 +00:00
|
|
|
#ifndef LINUX_EXPORTFS_H
|
|
|
|
#define LINUX_EXPORTFS_H 1
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
|
|
|
struct dentry;
|
2013-10-28 09:32:35 +00:00
|
|
|
struct iattr;
|
2007-10-21 23:42:05 +00:00
|
|
|
struct inode;
|
2016-06-20 23:22:39 +00:00
|
|
|
struct iomap;
|
2007-07-17 11:04:28 +00:00
|
|
|
struct super_block;
|
2007-07-17 11:04:30 +00:00
|
|
|
struct vfsmount;
|
2007-07-17 11:04:28 +00:00
|
|
|
|
2011-01-29 13:13:26 +00:00
|
|
|
/* limit the handle size to NFSv4 handle size now */
|
|
|
|
#define MAX_HANDLE_SZ 128
|
|
|
|
|
2007-10-21 23:42:03 +00:00
|
|
|
/*
|
|
|
|
* The fileid_type identifies how the file within the filesystem is encoded.
|
|
|
|
* In theory this is freely set and parsed by the filesystem, but we try to
|
|
|
|
* stick to conventions so we can share some generic code and don't confuse
|
|
|
|
* sniffers like ethereal/wireshark.
|
|
|
|
*
|
|
|
|
* The filesystem must not use the value '0' or '0xff'.
|
|
|
|
*/
|
|
|
|
enum fid_type {
|
|
|
|
/*
|
|
|
|
* The root, or export point, of the filesystem.
|
|
|
|
* (Never actually passed down to the filesystem.
|
|
|
|
*/
|
|
|
|
FILEID_ROOT = 0,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 32bit inode number, 32 bit generation number.
|
|
|
|
*/
|
|
|
|
FILEID_INO32_GEN = 1,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 32bit inode number, 32 bit generation number,
|
|
|
|
* 32 bit parent directory inode number.
|
|
|
|
*/
|
|
|
|
FILEID_INO32_GEN_PARENT = 2,
|
2008-04-30 15:22:06 +00:00
|
|
|
|
2008-08-20 13:58:23 +00:00
|
|
|
/*
|
|
|
|
* 64 bit object ID, 64 bit root object ID,
|
|
|
|
* 32 bit generation number.
|
|
|
|
*/
|
|
|
|
FILEID_BTRFS_WITHOUT_PARENT = 0x4d,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 64 bit object ID, 64 bit root object ID,
|
|
|
|
* 32 bit generation number,
|
|
|
|
* 64 bit parent object ID, 32 bit parent generation.
|
|
|
|
*/
|
|
|
|
FILEID_BTRFS_WITH_PARENT = 0x4e,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 64 bit object ID, 64 bit root object ID,
|
|
|
|
* 32 bit generation number,
|
|
|
|
* 64 bit parent object ID, 32 bit parent generation,
|
|
|
|
* 64 bit parent root object ID.
|
|
|
|
*/
|
|
|
|
FILEID_BTRFS_WITH_PARENT_ROOT = 0x4f,
|
|
|
|
|
2008-04-30 15:22:06 +00:00
|
|
|
/*
|
|
|
|
* 32 bit block number, 16 bit partition reference,
|
|
|
|
* 16 bit unused, 32 bit generation number.
|
|
|
|
*/
|
|
|
|
FILEID_UDF_WITHOUT_PARENT = 0x51,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 32 bit block number, 16 bit partition reference,
|
|
|
|
* 16 bit unused, 32 bit generation number,
|
|
|
|
* 32 bit parent block number, 32 bit parent generation number
|
|
|
|
*/
|
|
|
|
FILEID_UDF_WITH_PARENT = 0x52,
|
2010-08-26 15:23:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 64 bit checkpoint number, 64 bit inode number,
|
|
|
|
* 32 bit generation number.
|
|
|
|
*/
|
|
|
|
FILEID_NILFS_WITHOUT_PARENT = 0x61,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 64 bit checkpoint number, 64 bit inode number,
|
|
|
|
* 32 bit generation number, 32 bit parent generation.
|
|
|
|
* 64 bit parent inode number.
|
|
|
|
*/
|
|
|
|
FILEID_NILFS_WITH_PARENT = 0x62,
|
2012-08-29 14:10:10 +00:00
|
|
|
|
2013-04-29 23:21:11 +00:00
|
|
|
/*
|
|
|
|
* 32 bit generation number, 40 bit i_pos.
|
|
|
|
*/
|
|
|
|
FILEID_FAT_WITHOUT_PARENT = 0x71,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 32 bit generation number, 40 bit i_pos,
|
|
|
|
* 32 bit parent generation number, 40 bit parent i_pos
|
|
|
|
*/
|
|
|
|
FILEID_FAT_WITH_PARENT = 0x72,
|
|
|
|
|
2016-02-15 00:13:52 +00:00
|
|
|
/*
|
|
|
|
* 128 bit child FID (struct lu_fid)
|
|
|
|
* 128 bit parent FID (struct lu_fid)
|
|
|
|
*/
|
|
|
|
FILEID_LUSTRE = 0x97,
|
|
|
|
|
2019-11-04 23:54:30 +00:00
|
|
|
/*
|
|
|
|
* 64 bit unique kernfs id
|
|
|
|
*/
|
|
|
|
FILEID_KERNFS = 0xfe,
|
|
|
|
|
2012-08-29 14:10:10 +00:00
|
|
|
/*
|
|
|
|
* Filesystems must not use 0xff file ID.
|
|
|
|
*/
|
|
|
|
FILEID_INVALID = 0xff,
|
2007-10-21 23:42:03 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct fid {
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
u32 ino;
|
|
|
|
u32 gen;
|
|
|
|
u32 parent_ino;
|
|
|
|
u32 parent_gen;
|
|
|
|
} i32;
|
2008-04-30 15:22:06 +00:00
|
|
|
struct {
|
|
|
|
u32 block;
|
|
|
|
u16 partref;
|
|
|
|
u16 parent_partref;
|
|
|
|
u32 generation;
|
|
|
|
u32 parent_block;
|
|
|
|
u32 parent_generation;
|
|
|
|
} udf;
|
2008-04-08 12:12:52 +00:00
|
|
|
__u32 raw[0];
|
2007-10-21 23:42:03 +00:00
|
|
|
};
|
|
|
|
};
|
2007-07-17 11:04:28 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* struct export_operations - for nfsd to communicate with file systems
|
|
|
|
* @encode_fh: encode a file handle fragment from a dentry
|
2008-03-14 13:11:29 +00:00
|
|
|
* @fh_to_dentry: find the implied object and get a dentry for it
|
|
|
|
* @fh_to_parent: find the implied object's parent and get a dentry for it
|
2007-07-17 11:04:28 +00:00
|
|
|
* @get_name: find the name for a given inode in a given directory
|
|
|
|
* @get_parent: find the parent of a given directory
|
2010-02-17 20:05:11 +00:00
|
|
|
* @commit_metadata: commit metadata changes to stable storage
|
2007-07-17 11:04:28 +00:00
|
|
|
*
|
2019-07-26 12:51:27 +00:00
|
|
|
* See Documentation/filesystems/nfs/exporting.rst for details on how to use
|
2007-10-21 23:42:19 +00:00
|
|
|
* this interface correctly.
|
2007-07-17 11:04:28 +00:00
|
|
|
*
|
|
|
|
* encode_fh:
|
|
|
|
* @encode_fh should store in the file handle fragment @fh (using at most
|
|
|
|
* @max_len bytes) information that can be used by @decode_fh to recover the
|
2011-03-31 01:57:33 +00:00
|
|
|
* file referred to by the &struct dentry @de. If the @connectable flag is
|
2007-07-17 11:04:28 +00:00
|
|
|
* set, the encode_fh() should store sufficient information so that a good
|
|
|
|
* attempt can be made to find not only the file but also it's place in the
|
|
|
|
* filesystem. This typically means storing a reference to de->d_parent in
|
2011-01-29 13:13:25 +00:00
|
|
|
* the filehandle fragment. encode_fh() should return the fileid_type on
|
|
|
|
* success and on error returns 255 (if the space needed to encode fh is
|
|
|
|
* greater than @max_len*4 bytes). On error @max_len contains the minimum
|
|
|
|
* size(in 4 byte unit) needed to encode the file handle.
|
2007-07-17 11:04:28 +00:00
|
|
|
*
|
2007-10-21 23:42:05 +00:00
|
|
|
* fh_to_dentry:
|
|
|
|
* @fh_to_dentry is given a &struct super_block (@sb) and a file handle
|
|
|
|
* fragment (@fh, @fh_len). It should return a &struct dentry which refers
|
|
|
|
* to the same file that the file handle fragment refers to. If it cannot,
|
2016-08-04 00:19:06 +00:00
|
|
|
* it should return a %NULL pointer if the file cannot be found, or an
|
|
|
|
* %ERR_PTR error code of %ENOMEM if a memory allocation failure occurred.
|
|
|
|
* Any other error code is treated like %NULL, and will cause an %ESTALE error
|
|
|
|
* for callers of exportfs_decode_fh().
|
|
|
|
* Any suitable dentry can be returned including, if necessary, a new dentry
|
|
|
|
* created with d_alloc_root. The caller can then find any other extant
|
|
|
|
* dentries by following the d_alias links.
|
2007-10-21 23:42:05 +00:00
|
|
|
*
|
|
|
|
* fh_to_parent:
|
|
|
|
* Same as @fh_to_dentry, except that it returns a pointer to the parent
|
|
|
|
* dentry if it was encoded into the filehandle fragment by @encode_fh.
|
|
|
|
*
|
2007-07-17 11:04:28 +00:00
|
|
|
* get_name:
|
|
|
|
* @get_name should find a name for the given @child in the given @parent
|
|
|
|
* directory. The name should be stored in the @name (with the
|
2020-08-12 01:34:00 +00:00
|
|
|
* understanding that it is already pointing to a %NAME_MAX+1 sized
|
2007-07-17 11:04:28 +00:00
|
|
|
* buffer. get_name() should return %0 on success, a negative error code
|
|
|
|
* or error. @get_name will be called without @parent->i_mutex held.
|
|
|
|
*
|
|
|
|
* get_parent:
|
|
|
|
* @get_parent should find the parent directory for the given @child which
|
|
|
|
* is also a directory. In the event that it cannot be found, or storage
|
|
|
|
* space cannot be allocated, a %ERR_PTR should be returned.
|
|
|
|
*
|
2010-02-17 20:05:11 +00:00
|
|
|
* commit_metadata:
|
|
|
|
* @commit_metadata should commit metadata changes to stable storage.
|
|
|
|
*
|
2007-07-17 11:04:28 +00:00
|
|
|
* Locking rules:
|
|
|
|
* get_parent is called with child->d_inode->i_mutex down
|
|
|
|
* get_name is not (which is possibly inconsistent)
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct export_operations {
|
2012-04-02 18:34:06 +00:00
|
|
|
int (*encode_fh)(struct inode *inode, __u32 *fh, int *max_len,
|
|
|
|
struct inode *parent);
|
2007-10-21 23:42:05 +00:00
|
|
|
struct dentry * (*fh_to_dentry)(struct super_block *sb, struct fid *fid,
|
|
|
|
int fh_len, int fh_type);
|
|
|
|
struct dentry * (*fh_to_parent)(struct super_block *sb, struct fid *fid,
|
|
|
|
int fh_len, int fh_type);
|
2007-07-17 11:04:28 +00:00
|
|
|
int (*get_name)(struct dentry *parent, char *name,
|
|
|
|
struct dentry *child);
|
|
|
|
struct dentry * (*get_parent)(struct dentry *child);
|
2010-02-17 20:05:11 +00:00
|
|
|
int (*commit_metadata)(struct inode *inode);
|
2013-10-28 09:32:35 +00:00
|
|
|
|
|
|
|
int (*get_uuid)(struct super_block *sb, u8 *buf, u32 *len, u64 *offset);
|
|
|
|
int (*map_blocks)(struct inode *inode, loff_t offset,
|
|
|
|
u64 len, struct iomap *iomap,
|
|
|
|
bool write, u32 *device_generation);
|
|
|
|
int (*commit_blocks)(struct inode *inode, struct iomap *iomaps,
|
|
|
|
int nr_iomaps, struct iattr *iattr);
|
2021-01-29 19:26:29 +00:00
|
|
|
u64 (*fetch_iversion)(struct inode *);
|
nfsd: close cached files prior to a REMOVE or RENAME that would replace target
It's not uncommon for some workloads to do a bunch of I/O to a file and
delete it just afterward. If knfsd has a cached open file however, then
the file may still be open when the dentry is unlinked. If the
underlying filesystem is nfs, then that could trigger it to do a
sillyrename.
On a REMOVE or RENAME scan the nfsd_file cache for open files that
correspond to the inode, and proactively unhash and put their
references. This should prevent any delete-on-last-close activity from
occurring, solely due to knfsd's open file cache.
This must be done synchronously though so we use the variants that call
flush_delayed_fput. There are deadlock possibilities if you call
flush_delayed_fput while holding locks, however. In the case of
nfsd_rename, we don't even do the lookups of the dentries to be renamed
until we've locked for rename.
Once we've figured out what the target dentry is for a rename, check to
see whether there are cached open files associated with it. If there
are, then unwind all of the locking, close them all, and then reattempt
the rename.
None of this is really necessary for "typical" filesystems though. It's
mostly of use for NFS, so declare a new export op flag and use that to
determine whether to close the files beforehand.
Signed-off-by: Jeff Layton <jeff.layton@primarydata.com>
Signed-off-by: Lance Shelton <lance.shelton@hammerspace.com>
Signed-off-by: Trond Myklebust <trond.myklebust@hammerspace.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
2020-11-30 22:03:16 +00:00
|
|
|
#define EXPORT_OP_NOWCC (0x1) /* don't collect v3 wcc data */
|
|
|
|
#define EXPORT_OP_NOSUBTREECHK (0x2) /* no subtree checking */
|
|
|
|
#define EXPORT_OP_CLOSE_BEFORE_UNLINK (0x4) /* close files before unlink */
|
2020-11-30 22:03:19 +00:00
|
|
|
#define EXPORT_OP_REMOTE_FS (0x8) /* Filesystem is remote */
|
2020-12-01 04:14:27 +00:00
|
|
|
#define EXPORT_OP_NOATOMIC_ATTR (0x10) /* Filesystem cannot supply
|
|
|
|
atomic attribute updates
|
|
|
|
*/
|
2020-11-30 22:03:14 +00:00
|
|
|
unsigned long flags;
|
2007-07-17 11:04:28 +00:00
|
|
|
};
|
|
|
|
|
2012-12-18 00:05:08 +00:00
|
|
|
extern int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
|
|
|
|
int *max_len, struct inode *parent);
|
2007-10-21 23:42:03 +00:00
|
|
|
extern int exportfs_encode_fh(struct dentry *dentry, struct fid *fid,
|
|
|
|
int *max_len, int connectable);
|
2020-11-30 22:03:17 +00:00
|
|
|
extern struct dentry *exportfs_decode_fh_raw(struct vfsmount *mnt,
|
|
|
|
struct fid *fid, int fh_len,
|
|
|
|
int fileid_type,
|
|
|
|
int (*acceptable)(void *, struct dentry *),
|
|
|
|
void *context);
|
2007-10-21 23:42:03 +00:00
|
|
|
extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
|
2007-07-17 11:04:30 +00:00
|
|
|
int fh_len, int fileid_type, int (*acceptable)(void *, struct dentry *),
|
|
|
|
void *context);
|
|
|
|
|
2007-10-21 23:42:05 +00:00
|
|
|
/*
|
|
|
|
* Generic helpers for filesystems.
|
|
|
|
*/
|
|
|
|
extern struct dentry *generic_fh_to_dentry(struct super_block *sb,
|
|
|
|
struct fid *fid, int fh_len, int fh_type,
|
|
|
|
struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
|
|
|
|
extern struct dentry *generic_fh_to_parent(struct super_block *sb,
|
|
|
|
struct fid *fid, int fh_len, int fh_type,
|
|
|
|
struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
|
|
|
|
|
2007-07-17 11:04:28 +00:00
|
|
|
#endif /* LINUX_EXPORTFS_H */
|