Patent Publication Number: US-8543602-B2

Title: Access controller that controls access to files by using access control list

Description:
CROSS-REFERENCE TO PRIOR APPLICATION 
     The present application is a continuation of application Ser. No. 12/020,760, filed Jan. 28, 2008 now U.S. Pat. No. 8,260,811; which relates to and claims the benefit of priority from Japanese Patent Application number 2007-241563, filed on Sep. 18, 2007, the entire disclosure of which is incorporated herein by reference. 
    
    
     BACKGROUND OF THE INVENTION 
     The present invention generally relates to a technology for controlling access to files by using a file control list. 
     Generally, a file server (for example, NAS (Network Attached Storage)) is used in order to share files between a plurality of clients (users). Access to the shared files is controlled using an access control list (‘ACL’ hereinbelow). The ACL describes which users are able to access files in which operations, for example. 
     Representative examples of ACL include POSIX ACL, which is used by UNIX (registered trademark), and NTFS ACL, which is employed by Windows (registered trademark). The POSIX is an abbreviation for Portable Operating System Interface and NTFS is an abbreviation for NT FileSystem. Although there are a lot of file servers compatible with only POSIX ACL, there are also file servers that are compatible with NTFS ACL. 
     POSIX ACL and NTFS ACL are not directly interchangeable. As a result, in order to perform access control using NTFS ACL, it is necessary to switch the file system from a file system of a type which corresponds with POSIX ACL to a file system of a type that corresponds with NTFS ACL. More specifically, for example, it is necessary to temporarily stop services (stop accepting file access requests from the client, for example) and, while services are stopped, generate and associate, for each file, NTFS ACL which correspond with the file system following the switch using the procedure disclosed by Japanese Application Laid Open No. 2005-78612, for example. 
     In general, the number of files stored in a storage device is huge. For this reason, when the generation of ACL which corresponds with the file system of the type following the switch is performed for all files, the length of time services are stopped increases. The length of service stoppage time is desirably as short as possible and ideally zero. 
     SUMMARY OF THE INVENTION 
     Therefore, an object of the present invention is to be able to perform access control using an ACL that corresponds with a file system of the type following the switch without stopping services. 
     Further objects of the present invention will become evident from the following description. 
     An ACL which corresponds with a file system of the type following the switching is not generated for all the files when the type of the file system is switched. Rather, each time the file access request is received, it is discriminated whether there is an ACL which corresponds with the file system of the type following the switching in the file designated by the file access request. In cases where the judgment result is that there is no such ACL, an ACL which corresponds with the file system of the type following the switching is generated on the basis of an ACL which corresponds with the file system of the type prior to the switching which is associated with the designated file and the ACL thus generated is used to control access in accordance with the received file access request. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  shows a constitutional example of the whole system according to a first embodiment of the present invention; 
         FIG. 2A  is a flowchart for switching the file system type; 
         FIG. 2B  shows a flowchart for background ACL conversion processing; 
         FIG. 2C  shows a flowchart for ACL conversion processing in directory units; 
         FIG. 3  is a flowchart for CIFS file services; 
         FIG. 4  is a flowchart for access feasibility judgment processing which is S 400  of  FIG. 3 ; 
         FIG. 5  is a flowchart for ACL conversion processing in file units; 
         FIG. 6  is a flowchart for the write necessity judgment processing of the first embodiment; 
         FIG. 7  is a flowchart for write necessity judgment processing of a second embodiment of the present invention; 
         FIG. 8  is a flowchart for write necessity judgment processing of a third embodiment of the present invention; 
         FIG. 9A  is a flowchart for first cache flush daemon processing according to a fourth embodiment of the present invention; 
         FIG. 9B  is a flowchart for second cache flush daemon processing of the fourth embodiment; 
         FIG. 10  shows a flowchart for restore processing; 
         FIG. 11A  shows an example of a file part that is constituted by file metadata, a POSIX ACL and an NTFS ACL; 
         FIG. 11B  shows file system type information that represents a file system that corresponds with POSIX ACL; 
         FIG. 11C  shows file system type information that represents a file system that corresponds with NTFS ACL; 
         FIG. 12  is a flowchart for capacity response processing according to a fifth embodiment of the present invention; and 
         FIG. 13  is a flowchart for NTFS ACL update processing that is performed according to a sixth embodiment of the present invention. 
     
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     According to Embodiment 1, an access controller that receives a file access request and uses an ACL to access the file designated by the file access request comprises an ACL judgment module, an ACL generation module, and an access control module. The ACL judgment module judges whether a first type of ACL which corresponds with a first type of file system is associated with a file designated by the file access request in response to receiving the file access request. The ACL generation module generates the first type of ACL on the basis of a second type of ACL which corresponds with the second type of file system which is already associated with the designated file when the result of the judgment is negative. The access control module controls access to the designated file by using the first type of ACL thus generated. According to the first embodiment, each time a file access request is received, if there is no first type of ACL in the designated file, a first type of ACL is generated based on the existing second type of ACL and access control is performed using the first type of ACL thus generated. Hence, even when the type of file system is switched from the second type to the first type, services are not stopped and access control using the first type of ACL can be performed. 
     In Embodiment 2, the access controller according to Embodiment 1 further comprises a switching instruction reception module that receives a switching instruction to switch the type of the file system or the type of the ACL to be used from the second type to the first type; and a switching module that switches the type of the file system or the type of the ACL from the second type to the first type in response to the switching instruction. The ACL generation module generates the first type of ACL on the basis of the second type of ACL which corresponds with the file designated by the file access request in cases where the result of the judgment performed in response to receiving the file access request is negative after the type of the file system or the type of the ACL to be used is switched from the second type to the first type. 
     In Embodiment 3, the access controller according to the Embodiment 2 further comprises a storage resource that stores type information indicating the type of the file system or the type of the ACL to be used. The ACL judgment module is constituted to specify the type of the current file system or ACL by referencing the type information. The switching module completes the switching of the type of the file system or the type of the ACL to be used from the second type to the first type by updating the type information from information indicating the second type to information indicating the first type. 
     In Embodiment 4, the access controller according to any one of Embodiments 1 to 3 further comprises a memory (may be a volatile or involatile memory). The ACL generation module judges whether the first type of ACL thus generated can be written to a logical storage space which comprises files managed by the file system or not and, if judged that writing is possible, the ACL generation module writes the first type of ACL corresponding with the file to both the logical storage space and the memory and, if judged that writing is impossible, the ACL generation module does not write the first type of ACL corresponding with the file to the logical storage space and writes the first type of ACL to the memory. The ACL judgment module performs a judgment of whether the first type of ACL designated by the received file access request is associated by referencing the memory and, in cases where the first type of ACL which corresponds with the file is stored in the memory, the result of the judgment is affirmative. According to Embodiment 4, irrespective of whether a file access request that indicates reading is received from a client, for example, even when an error whereby the first type of ACL is not written to the logical storage space due to the capacity of the logical storage space being exhausted or similar arises, the file system is able to report an error in writing the first type of ACL to the memory to the client. 
     In Embodiment 5, the access controller according to Embodiment 4 is such that, in any of the following cases (1) to (3), the ACL generation module judges that the generated first type of ACL cannot be written to the logical storage space:
         (1) a case where a spare capacity of a magnitude permitting storage of the generated first type of ACL does not exist in the logical storage space;   (2) a case where the difference between the used capacity or spare capacity of the logical storage space and a preset control value is a predetermined value; and   (3) a case where an access attribute signifying that reading is possible but writing is impossible is associated with the logical storage space.       

     In Embodiment 6, the access controller according to Embodiment 4 or 5 further comprises an ACL destage module. The ACL destage module monitors whether the first type of ACL can be written to the logical storage space and, when detected that writing is possible, writes the first type of ACL that has not yet been written to the logical storage device and which is stored in the memory to the logical storage space. According to Embodiment 6, a situation where the first type of ACL will not be written to the logical storage space indefinitely can be prevented. 
     In Embodiment 7, the access controller according to any one of Embodiments 1 to 3 is such that, even when an access attribute signifying that reading is possible but writing is impossible is associated with the logical storage space that comprises files managed by the file system, the ACL generation module writes the first type of ACL which is associated with the designated file to the logical storage space. According to Embodiment 7, the first type of ACL is written to the logical storage space even in a situation where writing by the client is logically prohibited because the file system has been mounted as a read only file system. Hence, the burden of having to generate the first type of ACL each time a file access request designating the same file is received can be suppressed. 
     In Embodiment 8, the access controller according to any one of Embodiments 1 to 7 is such that the ACL judgment module judges whether the first type of ACL is associated with all the files that exist in the logical storage space while accepting the file access request. The ACL generation module generates, each time a negative judgment result is obtained, the first type of ACL which corresponds with the file which corresponds with the negative judgment result on the basis of the second type of ACL which corresponds with the file. According to Embodiment 8, a situation where a file exists that will not be accessed indefinitely but for which the first type of ACL will therefore not be prepared can be prevented from occurring. 
     In Embodiment 9, the access controller according to any one of Embodiments 1 to 8 further comprises a capacity inquiry reception module that receives an inquiry regarding the used capacity or spare capacity of the logical storage space managed by the file system; and a capacity response module that sends back the used capacity or spare capacity in cases where assumption is made that the first type of ACL is associated with all of the files in the logical storage space. According to Embodiment 9, because the used capacity or spare capacity is sent back in cases where it is assumed that the first type of ACL exists, a situation where the file system is full as a result of the writing of the first type of ACL and where the desired file is not written can be prevented. 
     In Embodiment 10, the access controller according to any one of Embodiments 1 to 9 is such that, in cases where the second type of ACL corresponding with the file with which the first type of ACL is associated is updated, the ACL generation module updates the first type of ACL on the basis of the updated second type of ACL. According to Embodiment 10, the integrity of the second type of ACL and first type of ACL can be assured. 
     In Embodiment 11, the access controller according to any one of Embodiments 1 to 10 is such that, in cases where a file with which the first type of ACL is associated is updated to a restored file as a result of a backed up file and the corresponding second type of ACL being restored, the ACL generation module associates a first type of ACL, which is generated on the basis of the restored second type of ACL and corresponds with the updated file, with the updated file constituting the restored file rather than the first type of ACL which corresponds with the pre-update file. According to Embodiment 11, an image that is backed up prior to the switching of the file system type can be restored as an image which corresponds with the file system following the switching of the file system type and the generated first type of ACL can be made the first type of ACL which corresponds with the second type of ACL at the time of the backup. 
     In Embodiment 12, the access controller according to any one of Embodiments 1 to 11 is such that the ACL generation module writes the generated first type of ACL to the memory and writes, in cases where the first type of ACL stored in the memory is used by the access control module a prescribed number of times or more, the first type of ACL stored in the memory to the logical storage space which comprises files managed by the file system. According to Embodiment 12, because the number of times the first type of ACL is written can be suppressed, the storage device based on the logical storage space is considered useful in cases that are characterized by restrictions on the number of possible writes, a slower write speed than read speed, and/or a higher cost of writing than cost of reading. 
     Two or more of the above mentioned Embodiments 1 to 12 can be combined. Further, one or more of above the modules (the ACL judgment module, ACL conversion module, access control module, instruction reception module, switching module, ACL destage module, capacity inquiry reception module, and capacity response module) can be constructed by hardware, a computer program, or a combination of hardware and computer programs (for example, some are implemented by a computer program while the remainder are implemented by hardware). The computer programs are read to a predetermined processor where same are executed. Further, at the time of information processing in which a computer program is read to the processor and executed, a storage area that exists in a hardware resource such as the memory may also suitably be used. Furthermore, the computer programs may be installed on a computer from a recording medium such as a CD-ROM or may be downloaded to a computer via a communication network. 
     Embodiments of the present invention will be described hereinbelow with reference to the drawings. 
     First Embodiment 
       FIG. 1  shows a constitutional example of the whole system according to the first embodiment of the present invention. 
     The NAS system ( 100 ) is constituted by a NAS control module ( 121 ) (a so-called ‘NAS head’, for example) and one or a plurality of storage devices ( 131 ). The storage devices ( 131 ) may, for example, be one or a plurality of storage media drives or a storage subsystem that comprises a plurality of storage media drives. 
     The NAS control module ( 121 ) is able to communicate with a CIFS (Common Internet File System) client ( 111 ) that issues CIFS-based file access requests and an NFS (Network File System) client ( 113 ) that issues NFS-based file access requests. The NAS control module ( 121 ) receives a file access request from client ( 111 ) or ( 113 ) and provides client ( 111 ) or ( 113 ) with services for accessing the file designated by the file access request which is stored in a region corresponding with a logical storage space ( 130 ) of the storage device ( 131 ).  FIG. 1  shows CIFS and NFS as examples of file services but file services are not limited to CIFS and NFS. Other file services such as FTP (File Transfer Protocol) and HTTP (HyperText Transfer Protocol) and so forth may also be adopted. 
     The NAS control module ( 121 ) is also able to communicate with a backup and restore server ( 112 ) which is a server for backing up and restoring files that are managed by a NAS manager ( 101 ) which is a computer that the manager uses in order to perform operations management or a NAS system ( 100 ). 
     The NAS control module ( 121 ) is logically divided into a user space and a kernel space. Information is exchanged between the respective spaces via a user kernel interface (‘interface’ is abbreviated to ‘I/F’ hereinbelow). In this embodiment, user kernel I/Fs include a file system type I/F ( 145 ), an ACL conversion I/F ( 146 ), and a file access I/F ( 147 ). These I/F ( 145 ), ( 146 ), and ( 147 ) are computer programs that are stored in memory (not shown), for example, and exhibit functions as a result of being executed by a microprocessor (not shown) that the NAS control module ( 121 ) comprises. 
     In the user space, a file system switching program ( 141 ) for switching the type of file system, a backup and restore agent ( 142 ) for performing a backup and restore, and a CIFS server ( 143 ), which processes file access requests form the CIFS client ( 111 ) are executed. However, in the kernel space, a file system information management module ( 122 ), which processes information on the file system, a file access module ( 123 ), which services file access, an ACL conversion module ( 126 ), which performs ACL conversion, and an NFS server ( 144 ), which processes file access requests from the NFS client ( 113 ) operate. These computer programs ( 141 ), ( 142 ), ( 143 ), ( 122 ), ( 123 ), ( 126 ), and ( 144 ) are stored in memory (not shown), for example, and exhibit functions as a result of being executed by the microprocessor (not shown) that the NAS control module ( 121 ) comprises. The ACL cache management module ( 125 ) manages an ACL cache ( 127 ) and the file system information management module ( 122 ) manages file system information ( 128 ). The ACL cache ( 127 ) is a volatile (or nonvolatile) cache memory or part of this cache memory, for example. The file system information ( 128 ) is stored in the memory (not shown) and contains information representing the type of file system, for example. 
     The storage device ( 131 ) stores file system type information ( 132 ) that represents the type of file system. In this embodiment, in order to establish an environment in which various access control, from access control using POSIX ACL to access control using NTFS ACL, is performed, the type of file system corresponding with the POSIX ACL is suitably called the ‘old-type’ and the type of file system corresponding with NTFS ACL is called the ‘new type’. The file system type information ( 132 ) indicates whether the type of the current file system is the old or new type. 
     In addition, the storage region corresponding to the logical storage space ( 130 ) that is managed by the file system of the storage device ( 131 ) stores one or more files ( 140 ). The files ( 140 ) are constituted by file metadata ( 136 ), a file main body ( 135 ), a POSIX ACL ( 134 ) and/or an NTFS ACL ( 133 ), for example. The files ( 140 ) shown in  FIG. 1  comprise the NTFS ACL ( 133 ) generated based on the POSIX ACL ( 134 ) rather than the POSIX ACL ( 134 ) because a file access request designating the file ( 140 ) has sometimes previously been received after the type of the file system has been switched from the old type to the new type. However, all the files ( 140 ) are not limited to comprising both the POSIX ACL ( 134 ) and the NTFS ACL ( 133 ) and sometimes comprise either the POSIX ACL ( 134 ) or the NTFS ACL ( 133 ). 
       FIG. 11A  shows an example of a file part that is constituted by file metadata, a POSIX ACL and an NTFS ACL. 
     The reference numeral  801  is the data part. The reference numeral  811  represents the name of an attribute and data fragments that represent the name of the attribute include the reference numerals  821 ,  831 ,  841 ,  851 , and  861  respectively. The reference numeral  812  indicates the actual value of the attribute and data fragments representing the value of the attribute include data fragments represented by the reference numerals  822 ,  832 ,  842 ,  852 , and  862  respectively. The data fragments constituting the file metadata are data fragments represented by the reference numerals  821 ,  822 ,  831 ,  832 ,  841  and  842  respectively. The data fragments constituting the POSIX ACL are data fragments represented by the reference numerals  851  and  852  respectively. The data fragments constituting the NTFS ACL are data fragments represented by the reference numerals  861  and  862  respectively. 
       FIGS. 11B and 11C  represent constitutional examples of the file system type information ( 132 ). 
     According to  FIG. 11B , the file system type information ( 132 ) represents a file system corresponding with the POSIX ACL, that is, the old type of file system. When the type of the file system is switched, the file system type information ( 132 ) is updated from the information shown in  FIG. 11B  to the information shown in  FIG. 11C , that is, to information representing the file system corresponding with the NTFS ACL, that is, the new type. 
     The flow of processing that is performed in this embodiment will be described hereinbelow. In the following description, in cases where the computer program is the subject, in reality, the processing is performed by a microprocessor (a CPU, for example) that executes the computer program. 
       FIG. 2A  is a flowchart for switching the file system type. The “S” in the reference numeral is an abbreviation for “step”. The switching of the file system type is performed in cases where the type of a file system with respect to which access control is performed using a POSIX ACL is shifted to the type of a file system that performs access control using NTFS ACL, for example. That is, the switching of the file system type is performed in cases where the type is switched from the old type to the new type of file system (and, conversely, may also be applied to switching from the new type to the old type of file system). 
     In S 201 , the file system type switching program ( 141 ) receives a switching instruction to switch the file system from the old type to the new type from the NAS manager  101  (or another device) and, in response to the switching instruction, calls the file system type I/F ( 145 ) in response to the switching instruction. The file system type I/F ( 145 ) calls the file system information management module ( 122 ). The file system information management module ( 122 ) updates the file system type of the designated file system. More specifically, the file system information management module ( 122 ) updates the file system type information ( 132 ) from the information recorded as the ‘file system using POSIX ACL’ (that is, the information shown in  FIG. 11B ) to the information recorded as the ‘file system using NTFS ACL’ (that is, the information shown in  FIG. 11C ). In addition, the file system information management module ( 122 ) writes file system information ( 126 ) comprising the updated file system type information ( 132 ) as cache to memory (not shown). 
     According to this embodiment, the switching of the file system type is completed simply by updating the file system type information ( 132 ). Thereafter, as will be described subsequently, NTFS ACL ( 133 ) must be associated with the file designated by the file access request whenever a file access request is received (must be included in the file) and the POSIX ACL ( 134 ) that are already associated with the file is converted to an NTFS ACL ( 133 ) (in other words, an NTFS ACL ( 133 ) is generated based on the POSIX ACL ( 134 )) and file access control using the converted NTFS ACL ( 133 ) is executed. In this embodiment, the pre-conversion POSIX ACL ( 134 ) is associated as is with the file without being destroyed by the conversion (when the conversion is complete, the pre-conversion POSIX ACL ( 134 ) may also be deleted by the ACL conversion module ( 126 )). 
     Thus, in this embodiment, because an NTFS ACL ( 133 ) is generated in response to the file access request, when there is a file that has not been designated by a file access request at any time, an NTFS ACL ( 134 ) has not been associated with this file at any time. 
     Therefore, in this embodiment, all the files in the designated logical storage space are scanned in the so-called background in parallel with a state in which the NTFS ACL ( 133 ) is generated in response to a file access request (that is, the file access request is accepted as is) and, if there is no NTFS ACL ( 133 ) in the file, processing to convert the POSIX ACL ( 134 ) that is associated with the file is converted to the NTFS ACL ( 133 ). 
       FIG. 2B  shows a flowchart for background ACL conversion processing.  FIG. 2C  shows a flowchart for ACL conversion processing in directory units. 
     In cases where an instruction for ACL conversion processing in the background (an instruction designating a directory, for example) is received from the NAS manager ( 101 ), the file system switching program ( 141 ) sets the designated directory for the file system root as the target directory (S 202 ). 
     Thereafter, the file system switching program ( 141 ) performs ACL conversion processing in directory units on the files belonging to the target directory (S 210 ). In ACL conversion processing, as shown in  FIG. 2C , the procedure from S 212  to S 215  is repeated with respect to all the files and directories in the target directory (S 211 ). 
     The file system switching program ( 141 ) calls the ACL conversion I/F ( 146 ) (S 212 ), the ACL conversion I/F ( 146 ) calls the ACL conversion module ( 126 ), and the ACL conversion module ( 126 ) carries out ACL conversion processing in file units (S 500 ). The details of the file-unit ACL conversion processing will be provided subsequently. 
     Thereafter, the file system switching program ( 141 ) judges whether the target is a directory (S 213 ) and, in cases where the target is a directory, executes directory-unit ACL conversion processing recursively. More specifically, the file system switching program ( 141 ) sets the directory as the target directory (S 214 ) and recursively calls the processing of S 210 . In cases where the target was not a directory, the processing returns to S 211 , whereupon the file-unit ACL conversion processing is executed with respect to the other files. 
     Once S 212  to S 215  have been carried out with respect to all the files and directories that exist in the directory established in S 202  of  FIG. 2B , S 210  of  FIG. 2B  comes to an end. 
     The flow of processing that is executed in cases where a file access request is received from client ( 111 ) or ( 113 ) following the switching of the file system type will be described next. 
       FIG. 3  is a flowchart for CIFS file services. Substantially the same processing is carried out for NFS and other file services. 
     First, the CIFS server ( 143 ) receives a file access request from the CIFS client ( 111 ) (S 301 ). 
     Thereafter, the CIFS server ( 143 ) calls the file access I/F ( 147 ) and issues a file access request to the kernel via the I/F ( 147 ) (S 302 ). 
     In response to the file access request, the access control module ( 124 ) in the file access module ( 123 ) judges whether it is possible to access the file that was designated by the user using the CIFS client ( 111 ) that is the source that issued the file access request (‘access user’ hereinbelow) (S 400 ). The details of the access feasibility judgment processing of S 400  will be described subsequently. However, the file-unit ACL conversion processing is also performed in this judgment processing. 
     In cases where access is permitted in the judgment of S 400 , the file access module ( 123 ) executes access in accordance with the request to the file that was designated by the file access request (writes or reads the file, for example) (S 303 ) and the CIFS server ( 143 ) sends the access result back to the CIFS client ( 111 ) that was the source of the file access request by way of response (S 304 ). If access is denied, the CIFS server ( 143 ) sends an error to the CIFS client ( 111 ) by way of response (S 305 ). 
     The CIFS file services end at that point. 
       FIG. 4  is a flowchart for access feasibility judgment processing which is S 400  of  FIG. 3 . 
     The access control module ( 124 ) judges the type of the current file system by calling the file system information management module ( 122 ) and referencing the file system information ( 128 ) (S 401 ). 
     In S 401 , in cases where the old type (file system that uses POSIX ACL) is judged, the access control module ( 124 ) uses the existing POSIX ACL in the file to judge the feasibility of access to the file designated by the file access request (S 402 ). 
     However, in cases where the new type (file system that uses NTFS ACL) is judged in S 401 , the access control module ( 124 ) executes ACL acquisition processing by calling the ACL cache management module ( 125 ). 
     The ACL cache management module ( 125 ) judges whether an NTFS ACL exists on the ACL cache ( 127 ) (S 403 ). 
     If it is judged in S 403  that an NTFS ACL exists in the ACL cache ( 127 ), the access control module ( 124 ) uses the NTFS ACL to judge the feasibility of access to the file that was designated by the file access request (S 405 ). 
     If it is judged in S 403  that there is no NTFS ACL in the ACL cache ( 127 ), the access control module ( 124 ) executes file-unit ACL conversion processing (S 500 ) (the ACL conversion processing (S 500 ) is the same as the processing called in  FIG. 2C  and will be described in detail in  FIG. 5  which follows). Thereafter, the ACL cache management module ( 125 ) writes the converted NTFS ACL (or the NTFS ACL that is already converted and stored in the storage device ( 131 )) to the ACL cache ( 127 ) (S 404 ). 
     The ACL acquisition processing ends as a result of the above steps. In S 405  which follows, an access feasibility judgment that uses the NTFS ACL thus written is performed. 
     The access feasibility judgment processing (S 400 ) ends as a result of the above steps. 
     The file-unit ACL conversion processing (S 500 ) will be described next with reference to  FIG. 5 . 
     First, the ACL conversion module ( 126 ) locks the file (the ‘target file’ in the description of  FIG. 5  hereinbelow) (S 501 ). 
     The ACL conversion module ( 126 ) then judges whether the file-unit ACL conversion processing has been called with an overwrite conversion flag (S 502 ). A case where the file-unit ACL conversion processing is called with an overwrite conversion flag is a case where the backup and restore agent ( 142 ) receives a restore instruction, as will be described subsequently. In this case, the processing of S 503  is skipped and the processing moves on to the processing of S 504 . 
     In a normal case where the file-unit ACL conversion processing is not called with an overwrite conversion flag, the ACL conversion module ( 126 ) judges whether an NTFS ACL is associated with the target file in the storage device ( 131 ) (S 503 ). If it is judged that an NTFS ACL is associated with the target file, the ACL conversion module ( 126 ) removes the lock on the target file (S 507 ) and terminates the file-unit ACL conversion processing. If it is judged that an NTFS ACL is not associated with the target file, the ACL conversion module ( 126 ) advances to the processing of S 504 . In S 503 , it may be judged whether there is an NTFS ACL by searching the storage device for an NTFS ACL or it may be judged whether a flag indicating the presence of an NTFS ACL exists in the file metadata of the target file. 
     If it is judged in S 503  that an NTFS ACL is not associated with the target file, the access control module ( 124 ) reads the POSIX ACL associated with the target file from the storage device ( 131 ) (S 504 ). 
     Thereafter, the ACL conversion module ( 126 ) converts the read POSIX ACL into an NTFS ACL (S 505 ). 
     The ACL conversion module ( 126 ) then judges whether it is necessary to write the NTFS ACL to the storage device ( 131 ) (S 600 ). The details of the writing necessity judgment processing will be described subsequently. 
     In cases where it is judged that writing is required in the writing necessity judgment processing, the ACL conversion module ( 126 ) writes the NTFS ACL that was converted in S 505  to the storage device ( 131 ) (S 506 ). More specifically, the ACL conversion module ( 126 ) associates the converted NTFS ACL with the target file in the storage device ( 131 ). The ACL conversion module ( 126 ) then advances to the processing of S 507 . 
     In cases where it is judged in the writing necessity judgment processing that writing is not required, the ACL conversion module ( 126 ) advances to the processing of S 507 . 
     In S 507 , the ACL conversion module ( 126 ) removes the lock on the target file (S 507 ). 
     The file-unit ACL conversion processing ends as a result of the above processing. The file-unit ACL conversion processing may include processing to write the NTFS ACL converted in S 505  to the ACL cache ( 127 ). Further, the file-unit ACL conversion processing that is performed in response to the file access request from the client ( 111 ) or ( 113 ) and the background file-unit ACL conversion processing are executed in parallel and, therefore, there is the possibility that a plurality of ACL conversion requests will be generated substantially at the same time for the same file (or directory). However, in this embodiment, from the point where the target file is locked until the target file is unlocked, only one process is permitted to access the POSIX ACL which corresponds with the target file and, therefore, the generation of a conflict with the POSIX ACL can be prevented. 
     The details of the writing necessity judgment processing (S 600 ) will be described next with reference to  FIG. 6 . 
     In S 601 , the ACL conversion module ( 126 ) references the file system information ( 128 ) and judges whether the file system managing the target file (the ‘target file system’ hereinbelow) is mounted as a read only file system. In cases where the file system has been mounted as a read only file system, the ACL conversion module ( 126 ) judges that writing is not required (S 605 ) and ends the processing. If the file system has not been mounted as a read only file system, the ACL conversion module ( 126 ) advances to S 602 . A read only mount means that an access attribute which indicates read only (reading is possible but writing is impossible) is associated with the target file system. 
     In S 602 , the ACL conversion module ( 126 ) judges whether the target file system has been exhausted (more specifically, for example, whether the spare capacity of the logical storage space containing all the files being managed by the target file system is not zero but substantially exhausted at a predetermined amount or whether the spare capacity is zero and therefore completely exhausted (the file system is full)). If it is judged that the spare capacity has been completely exhausted, the ACL conversion module ( 126 ) judges that writing is not required (S 605 ) and terminates the processing. If it is judged that the spare capacity has not been exhausted, the ACL conversion module ( 126 ) advances to S 603 . 
     In S 603 , the ACL conversion module ( 126 ) judges whether the difference between the utilization of the logical storage space managed by the target file system and the upper limit value of the target file quota is a predetermined value, for example, whether the utilization is close to the upper limit value of the target file quota (or has reached the upper limit value). If it is judged that the utilization is close to (or has reached) the quota upper limit value, the ACL conversion module ( 126 ) judges that writing is impossible (S 605 ) and terminates the processing. If this judgment is not made, the ACL conversion module ( 126 ) judges that writing is required (S 604 ) and terminates the processing. 
     In this embodiment, as shown in  FIG. 5 , although the writing necessity judgment processing (S 600 ) is carried out prior to actually writing the NTFS ACL (S 506 ), the writing necessity judgment processing (S 600 ) can be implemented so that specified errors are ignored when writing has been performed with respect to the storage device ( 131 ). For example, writing errors such as read only file system errors (EROFS), file system full errors (ENOSPC), and quota errors (EDQUOT) may be ignored. 
     According to the description hereinabove, even when a file access request designating a file with which an NTFS ACL has not been associated is received from the client ( 111 ) or ( 113 ), the POSIX ACL associated with the file can be converted into an NTFS ACL in response to the request and access control can be carried out by using the NTFS ACL. In addition, an NTFS ACL can be prepared by means of background ACL conversion processing with respect to a file that has not been accessed by the client ( 111 ) or ( 113 ). 
       FIG. 10  shows a flowchart for restore processing. 
     In cases where the backup restore agent ( 142 ) receives a restore instruction designating an archive image (backup image) from the backup and restore server ( 112 ), the processing of steps S 1002  to S 500  is repeated with respect to all the files and all the directories of the archive image. 
     In other words, the backup and restore agent ( 142 ) calls the file access module ( 123 ) via the file access I/F ( 147 ) and the access control module ( 124 ) creates the directories or files of the restore target in the storage device  131 , for example (S 1002 ). In the case of the files, the access control module ( 124 ) restores the file main body to the file created in S 1002  (S 1003 ). Further, the access control module ( 124 ) also restores the associated POSIX ACL and file metadata with the file created in S 1002  (S 1004 ). 
     Thereafter, the backup restore agent ( 142 ) calls the ACL conversion I/F ( 145 ) with the overwrite conversion flag (S 1005 ). 
     The ACL conversion module ( 126 ) executes the file unit ACL conversion processing (S 500 ). Here, as mentioned earlier, because the file unit ACL conversion processing is called with the overwrite conversion flag, S 502  in  FIG. 5  yields a YES and S 503  is not executed, and the processing of S 504  is executed. Here, because the POSIX ACL is acquired from the archive image, in cases where S 502  yields a YES, S 504  may be skipped and S 505  may be carried out. Further, the conversion to NTFS ACL is executed on the basis of the POSIX ACL acquired from the archive image. This is so that an NTFS ACL which corresponds with the POSIX ACL when the backup was acquired is generated. Because S 503  is not performed, an overwrite file exists as a result of the restore in the storage device ( 131 ) and, even when an NTFS ACL is already associated with the file, an NTFS ACL that is generated on the basis of the POSIX ACL when the backup was made is associated with the restored file rather than the existing NTFS ACL. 
     As a result of the above restore processing, a backup image that comprises files which are managed by the old-type file system (the file system corresponding with the POSIX ACL) can be restored as an image that comprises the files managed by the new-type file system (the file system corresponding with the NTFS ACL). 
     Second Embodiment 
     The second embodiment of the present invention will be described hereinbelow. Here, the differences from the first embodiment will be mainly described and a description of the points in common with the first embodiment will be omitted or simplified (the same is also true of the subsequent third to fifth embodiments). 
     In the writing necessity judgment processing of the first embodiment, in cases where the file system is a read only mount file system, the converted NTFS ACL is not written to the storage device ( 131 ) but can instead be processed as follows. 
       FIG. 7  is a flowchart for write necessity judgment processing of a second embodiment of the present invention. 
     The ACL conversion module ( 126 ) references the file system information ( 128 ) and judges whether the target file system has been mounted as a read only file system (S 701 ). In cases where the target file system has been mounted as a read only file system, the ACL conversion module ( 126 ) then judges whether the storage device ( 131 ) is a writable device (S 702 ). Here, writable devices include rewritable devices such as hard disks or flash memory, for example. However, unwritable devices include write-once devices such as CD-ROM, for example. 
     In cases where the file system has not been mounted as a read only file system and cases where the file system has been mounted as a read only file system but the storage device ( 131 ) is a writable device, the ACL conversion module ( 126 ) judges that writing is required (S 703 ) and terminates the processing. However, in cases where the file system has been mounted as a read only file system but the storage device ( 131 ) is an unwritable device, the ACL conversion module ( 126 ) judges that writing is impossible (S 704 ) and terminates the processing. Even when the file system has been mounted as a read only file system and the storage device ( 131 ) is a writable device, it many be judged that writing is not required due to other factors such as a file system full event. 
     The fact that the file system has been mounted as a read only file system means that the file system is logically unwritable but does not mean that the file system is physically unwritable. In this embodiment, if the file system has been mounted as a read only file system and the storage device ( 131 ) is a writable device, the converted NTFS ACL is written by the storage device ( 131 ). If the file system has been mounted as a read only file system, the writing of a file designated by a file access request can be prohibited by the access control module ( 124 ). That is, the writing of the file main body is prohibited in accordance with a read only mounted file system while the fact that the file system has been mounted as a read only file system can be ignored for the NTFS ACL which can be written to the storage device ( 131 ). 
     Third Embodiment 
       FIG. 8  is a flowchart for write necessity judgment processing of the third embodiment of the present invention. 
     The ACL conversion module ( 126 ) is information references file access statistical information (information representing statistics such as the file access count which is information that is updated each time a file is accessed, for example) and judges whether the file access count has reached a prescribed count (ten times, for example) (S 801 ). 
     In cases where the access count is less than the prescribed count, the ACL conversion module ( 126 ) judges that writing is not required (S 803 ) and terminates the processing. However, in cases where the access count is equal to or more than the prescribed count, the ACL conversion module ( 126 ) judges that writing is required (S 802 ) and terminates the processing. 
     Thus, where files for which access has only occurred a few times, compression of the spare capacity can be prevented due to the fact that the converted NTFS ACL is not written to the storage device ( 131 ). Further, in cases where the storage device ( 131 ) is constituted by a device with a low write speed and/or for which there are restrictions on the number of possible writes as is the case of flash memory or the like, this third embodiment is useful. 
     The writing necessity judgment processes that were described in the first to third embodiments can also be used in combination. For example, in the writing necessity judgment processing of the third embodiment, a check of the quota upper limit value of the writing necessity judgment processing of the first embodiment may also be carried out. 
     Fourth Embodiment 
     According to the fourth embodiment of the present invention, in the write necessity judgment processing, the NTFS ACL of the dirty for which the factor causing the write fault has been eliminated among the NTFS ACL for which writing is judged to be unnecessary (called ‘dirty NTFS ACL’ hereinbelow) are written to the storage device ( 131 ). In the fourth embodiment, first and second cache flush daemon processing is carried out. 
       FIG. 9A  is a flowchart for first cache flush daemon processing. 
     The ACL cache management module ( 125 ) judges whether a dirty NTFS ACL exists in the ACL cache ( 127 ) (S 901 ). When it is judged that a dirty NTFS ACL does not exist, the ACL cache management module ( 125 ) skips a fixed time ahead (five minutes, for example) (S 902 ) and performs S 901  once again. 
     In cases where it is judged that a dirty NTFS ACL exists, the ACL cache management module ( 125 ) judges whether the factor causing the write fault has been eliminated (S 903 ). Here, ‘factor causing the write fault’ is a factor causing a fault in the writing of an NTFS ACL to the storage device ( 131 ) and, more specifically, for example, signifies the exhaustion of the capacity of the logical storage space managed by the file system (file system full, for example) or the fact that the utilization of the logical storage space that is managed by the file system is close to or has reached the quota upper limit value. 
     If it is judged that the factor causing the write fault has been eliminated, the ACL cache management module ( 125 ) writes the dirty NTFS ACL in the ACL cache ( 127 ) to the storage device ( 131 ) (S 904 ) and returns the processing to S 901 . 
     If it is judged that the factor causing the write fault has not been eliminated, the ACL cache management module ( 125 ) does not write the dirty NTFS ACL in the ACL cache ( 127 ) to the storage device ( 131 ) and moves the processing to S 902  and returns to S 901 . 
     The above first cache flush daemon processing is carried out using the so-called poling method. That is, it is checked at regular intervals whether the cause of the write fault has been eliminated and, in cases where the cause of the write fault has been eliminated, the dirty NTFS ACL is written to the storage device ( 131 ). 
     In contrast, the second cache flush daemon processing is processing of a so-called event-driven system. In the fourth embodiment, one or both of the first and second cache flush daemon processes can be adopted. 
       FIG. 9B  is a flowchart for the second cache flush daemon processing. 
     Given a specified event such as an event where ‘an object (a file or an ACL in the file, for example) has been deleted from the logical storage space managed by the target file system’, for example, second cache flush daemon processing is started. 
     As per S 901 , the ACL cache management module ( 125 ) judges whether a dirty NTFS ACL exists in the ACL cache ( 127 ) (S 911 ), and terminates the processing if it is judged that a dirty NTFS ACL does not exist therein. 
     However, if it is judged that a dirty NTFS ACL exists in the ACL cache ( 127 ), the ACL cache management module ( 125 ) judges whether the factor causing the write fault has been eliminated as per S 903  (S 912 ). If it is judged that the factor causing the write fault has not been eliminated, the ACL cache management module ( 125 ) terminates the processing. 
     According to the judgment that the factor causing the fault has been eliminated, the ACL cache management module ( 125 ) writes the dirty NTFS ACL to the storage device ( 131 ) as per S 904  (S 913 ). The processing then returns to S 911 . 
     The processing that is described with reference to  FIG. 9A  and/or  FIG. 9B  may be performed in at least one of the first to third embodiments. 
     Fifth Embodiment 
       FIG. 12  is a flowchart for the capacity response processing that is executed in the fifth embodiment of the present invention. 
     Capacity response processing is processing that is executed in cases where an inquiry regarding the usage amount or spare capacity of the logical storage space managed by the file system is received from the NAS manager ( 101 ) or client ( 111 ) or ( 113 ) and processing to respond to the inquiry by sending back the usage amount or spare capacity. For example, the access control module ( 124 ) specifies, based on the file system, the current usage amount (or spare capacity) of the logical storage space designated by the inquiry and specifies a file without NTFS ACL (‘non-NTFS file’ hereinbelow) (S 1201 ). Further, the access control module ( 124 ) sends back a value obtained by adding the total of one or more NTFS ACL which correspond with one or more non-NTFS ACL files to the current usage amount (or a value obtained by subtracting the total of one or more NTFS ACL which correspond with one or more non-NTFS ACL files from the current spare capacity) to the source of the inquiry (S 1202 ). As a result, it can be expected that the exhaustion of the logical storage space when the NTFS ACL are actually created and written to the logical storage space will be prevented. 
     The processing described with reference to  FIG. 12  can also be performed in at least one of the first to fourth embodiments. 
     Sixth Embodiment 
       FIG. 13  is a flowchart for the update processing of the NTFS ACL that is performed in the sixth embodiment of the present invention. 
     The ACL conversion module ( 126 ) starts this processing in the event that the POSIX ACL is updated. If the NTFS ACL is associated with the file with which the updated POSIX ACL is associated (YES in S 1301 ), the ACL conversion module ( 126 ) updates the NTFS ACL on the basis of the updated POSIX ACL (S 1302 ). As a result, the integrity of the POSIX ACL and NTFS ACL can be preserved. 
     Conversely, in cases where the NTFS ACL is updated, the corresponding POSIX ACL may also be updated. The processing shown in  FIG. 13  can be performed in at least one of the first to sixth embodiments. 
     Embodiments of the present invention were described hereinabove but are examples which serve to illustrate the present invention, there being no intention to limit the scope of the present invention to these embodiments alone. The present invention can also be implemented using a variety of other forms. For example, all or some of the logical storage space managed by the file system may also be integrated as some of the GNS (Global Name Space). In addition, this processing may also be performed once again in cases where the generation of the NTFS ACL fails in S 505  of  FIG. 5  or file-unit ACL conversion processing may be terminated without performing this processing again (in the latter case, the NTFS ACL is generated when access takes place the next time and on subsequent occasions). Furthermore, with regard to background ACL conversion processing, for example, in cases where this processing ends abnormally when the NTFS ACL conversion fails for example, in the subsequent background ACL conversion processing, all the files may be scanned irrespective of whether scanning is complete or only the files that failed to undergo the ACL conversion in the previous ACL conversion processing and the unscanned files may be scanned.