/**
 * Sets the system-wide security manager.
 *
 * If there is a security manager already installed, this method first
 * calls the security manager's {@code checkPermission} method
 * with a {@code RuntimePermission("setSecurityManager")}
 * permission to ensure it's ok to replace the existing
 * security manager.
 * This may result in throwing a {@code SecurityException}.
 *
 * <p> Otherwise, the argument is established as the current
 * security manager. If the argument is {@code null} and no
 * security manager has been established, then no action is taken and
 * the method simply returns.
 *
 * @implNote In the JDK implementation, if the Java virtual machine is
 * started with the system property {@code java.security.manager} set to
 * the special token "{@code disallow}" then the {@code setSecurityManager}
 * method cannot be used to set a security manager.
 *
 * @param  sm the security manager or {@code null}
 * @throws SecurityException
 *         if the security manager has already been set and its {@code
 *         checkPermission} method doesn't allow it to be replaced
 * @throws UnsupportedOperationException
 *         if {@code sm} is non-null and a security manager is not allowed
 *         to be set dynamically
 * @see #getSecurityManager
 * @see SecurityManager#checkPermission
 * @see java.lang.RuntimePermission
 */
public static void setSecurityManager(SecurityManager sm) {
    if (allowSecurityManager()) {
        if (security == null) {
            // ensure image reader is initialized
            Object.class.getResource("java/lang/ANY");
            // ensure the default file system is initialized
            DefaultFileSystemProvider.theFileSystem();
        }
        if (sm != null) {
            try {
                // pre-populates the SecurityManager.packageAccess cache
                // to avoid recursive permission checking issues with custom
                // SecurityManager implementations
                sm.checkPackageAccess("java.lang");
            } catch (Exception e) {
                // no-op
            }
        }
        setSecurityManager0(sm);
    } else {
        // security manager not allowed
        if (sm != null) {
            throw new UnsupportedOperationException(
                "Runtime configured to disallow security manager");
        }
    }
}
 

/**
 * Returns the default {@code FileSystem}. The default file system creates
 * objects that provide access to the file systems accessible to the Java
 * virtual machine. The <em>working directory</em> of the file system is
 * the current user directory, named by the system property {@code user.dir}.
 * This allows for interoperability with the {@link java.io.File java.io.File}
 * class.
 *
 * <p> The first invocation of any of the methods defined by this class
 * locates the default {@link FileSystemProvider provider} object. Where the
 * system property {@code java.nio.file.spi.DefaultFileSystemProvider} is
 * not defined then the default provider is a system-default provider that
 * is invoked to create the default file system.
 *
 * <p> If the system property {@code java.nio.file.spi.DefaultFileSystemProvider}
 * is defined then it is taken to be a list of one or more fully-qualified
 * names of concrete provider classes identified by the URI scheme
 * {@code "file"}. Where the property is a list of more than one name then
 * the names are separated by a comma. Each class is loaded, using the system
 * class loader, and instantiated by invoking a one argument constructor
 * whose formal parameter type is {@code FileSystemProvider}. The providers
 * are loaded and instantiated in the order they are listed in the property.
 * If this process fails or a provider's scheme is not equal to {@code "file"}
 * then an unspecified error is thrown. URI schemes are normally compared
 * without regard to case but for the default provider, the scheme is
 * required to be {@code "file"}. The first provider class is instantiated
 * by invoking it with a reference to the system-default provider.
 * The second provider class is instantiated by invoking it with a reference
 * to the first provider instance. The third provider class is instantiated
 * by invoking it with a reference to the second instance, and so on. The
 * last provider to be instantiated becomes the default provider; its {@code
 * getFileSystem} method is invoked with the URI {@code "file:///"} to
 * get a reference to the default file system.
 *
 * <p> Subsequent invocations of this method return the file system that was
 * returned by the first invocation.
 *
 * @return  the default file system
 */
public static FileSystem getDefault() {
    if (VM.isModuleSystemInited()) {
        return DefaultFileSystemHolder.defaultFileSystem;
    } else {
        // always use the platform's default file system during startup
        return DefaultFileSystemProvider.theFileSystem();
    }
}