mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
![Greg Kroah-Hartman](/assets/img/avatar_default.png)
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>
231 lines
7.5 KiB
C
231 lines
7.5 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef LINUX_EXPORTFS_H
|
|
#define LINUX_EXPORTFS_H 1
|
|
|
|
#include <linux/types.h>
|
|
|
|
struct dentry;
|
|
struct iattr;
|
|
struct inode;
|
|
struct iomap;
|
|
struct super_block;
|
|
struct vfsmount;
|
|
|
|
/* limit the handle size to NFSv4 handle size now */
|
|
#define MAX_HANDLE_SZ 128
|
|
|
|
/*
|
|
* 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,
|
|
|
|
/*
|
|
* 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,
|
|
|
|
/*
|
|
* 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,
|
|
|
|
/*
|
|
* 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,
|
|
|
|
/*
|
|
* 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,
|
|
|
|
/*
|
|
* 128 bit child FID (struct lu_fid)
|
|
* 128 bit parent FID (struct lu_fid)
|
|
*/
|
|
FILEID_LUSTRE = 0x97,
|
|
|
|
/*
|
|
* Filesystems must not use 0xff file ID.
|
|
*/
|
|
FILEID_INVALID = 0xff,
|
|
};
|
|
|
|
struct fid {
|
|
union {
|
|
struct {
|
|
u32 ino;
|
|
u32 gen;
|
|
u32 parent_ino;
|
|
u32 parent_gen;
|
|
} i32;
|
|
struct {
|
|
u32 block;
|
|
u16 partref;
|
|
u16 parent_partref;
|
|
u32 generation;
|
|
u32 parent_block;
|
|
u32 parent_generation;
|
|
} udf;
|
|
__u32 raw[0];
|
|
};
|
|
};
|
|
|
|
/**
|
|
* struct export_operations - for nfsd to communicate with file systems
|
|
* @encode_fh: encode a file handle fragment from a dentry
|
|
* @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
|
|
* @get_name: find the name for a given inode in a given directory
|
|
* @get_parent: find the parent of a given directory
|
|
* @commit_metadata: commit metadata changes to stable storage
|
|
*
|
|
* See Documentation/filesystems/nfs/Exporting for details on how to use
|
|
* this interface correctly.
|
|
*
|
|
* 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
|
|
* file referred to by the &struct dentry @de. If the @connectable flag is
|
|
* 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
|
|
* 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.
|
|
*
|
|
* 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,
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
* 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
|
|
* understanding that it is already pointing to a a %NAME_MAX+1 sized
|
|
* 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.
|
|
*
|
|
* commit_metadata:
|
|
* @commit_metadata should commit metadata changes to stable storage.
|
|
*
|
|
* Locking rules:
|
|
* get_parent is called with child->d_inode->i_mutex down
|
|
* get_name is not (which is possibly inconsistent)
|
|
*/
|
|
|
|
struct export_operations {
|
|
int (*encode_fh)(struct inode *inode, __u32 *fh, int *max_len,
|
|
struct inode *parent);
|
|
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);
|
|
int (*get_name)(struct dentry *parent, char *name,
|
|
struct dentry *child);
|
|
struct dentry * (*get_parent)(struct dentry *child);
|
|
int (*commit_metadata)(struct inode *inode);
|
|
|
|
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);
|
|
};
|
|
|
|
extern int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
|
|
int *max_len, struct inode *parent);
|
|
extern int exportfs_encode_fh(struct dentry *dentry, struct fid *fid,
|
|
int *max_len, int connectable);
|
|
extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
|
|
int fh_len, int fileid_type, int (*acceptable)(void *, struct dentry *),
|
|
void *context);
|
|
|
|
/*
|
|
* 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));
|
|
|
|
#endif /* LINUX_EXPORTFS_H */
|