89 results about "POSIX" patented technology

A data object management scheme for storing a large plurality of small data objects (e.g., image files) in small number of large object stack file for storage in secondary storage (e.g., hard disks). By storing many individual data objects in a single object stack file, the number of files stored in the secondary storage is reduced by several orders of magnitude, from the billions or millions to the hundreds or so. Index data for each object stack file is generated and stored in primary storage to allow efficient and prompt access to the data objects. Requests to store or retrieve the data objects are made using HTTP messages including file identifiers that identify the files storing the data objects and keys identifying the data objects. A file server stores or retrieves the data object from secondary storage of a file server without converting the requests to NSF or POSIX commands.

Example embodiments of the present invention includes systems and methods for implementing a scalable symmetric multiprocessing (shared memory) computer architecture using a network of homogeneous multi-core servers. The level of processor and memory performance achieved is suitable for running applications that currently require cache coherent shared memory mainframes and supercomputers. The architecture combines new operating system extensions with a high-speed network that supports remote direct memory access to achieve an effective global distributed shared memory. A distributed thread model allows a process running in a head node to fork threads in other (worker) nodes that run in the same global address space. Thread synchronization is supported by a distributed mutex implementation. A transactional memory model allows a multi-threaded program to maintain global memory page consistency across the distributed architecture. A distributed file access implementation supports non-contentious file I / O for threads. These and other functions provide a symmetric multiprocessing programming model consistent with standards such as Portable Operating System Interface for Unix (POSIX).

Synchronization software in a computer operating system evaluates with respect to an exposure goal the ages of byte stream files queued for synchronization, and dynamically adjusts synchronization ("sync") capacity in response to the evaluation. The synchronization of byte stream files occurs at rates responsive to the sync capacity. Several parameters are used to adjust sync capacity: a lead time, the number of active sync tasks, and the priority of the sync tasks. These parameters are adjusted in a manner to impact system performance to the least extent possible.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

A long transaction is a transaction which contains multiple atomic transactions and is longer in executing time. The serial execution for the atomic transactions not only costs longer executing time for the long transaction but also occupies more system resources and causes the reduction of the running efficiency of the system. The invention discloses a multithreading-based parallel executing method for a long transaction, which comprises the following steps: (1) formally describing the long transaction as an expanding directed graph; (2) cutting LT (Language Transaction) into a plurality of sub-transactions LT capable of being executed in a parallel form and giving a cutting algorithm; (3) deriving a plurality of sub-threads on the basis of POSIX (Portable Operating System Interface of Unix) threading library (or Windows threading API (Application Program Interface)), so as to execute the long transaction in a parallel embedding mode; and (4) running paralleled codes on a multi-core processor (or a multi-CPU (Central Processing Unit) processor). According to the multithreading-based parallel executing method for the long transaction, the executing time for the long transaction is obviously shortened, the executing efficiency for the long transaction is increased, and the method can be applied to the fields, such as SOA (Service Oriented Architecture), service combination, transaction treatment, and the like.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

Embodiments of the present invention provide a method and a system of file access. The method comprises that: a file system driving module receives a first access request sent by an upper application; the file system driving module, according to the corresponding relation between an access interface corresponding to the upper application and an access interface of the key-value database, converts the first access request into a second access request which is suitable for access to the key-value database; the file system driving module sends the second access request to a client of the key-value database; and the client of the key-value database, according to the second access request, searches corresponding file content or directory entry content or file attributes or directory entry attributes from the key-value database which is stored in a server of the key-value database. When the technical schemes in the embodiments are compared with technical schemes of layer-by-layer access of metadata in file systems of POSIX in the prior art, access cost is relatively small and access efficiency is relatively high.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

The invention provides for extracting language and culture information from a POSIX(TM)* conforming locale source file for the purpose of formatting sample data for country and language expert validation. The invention is performed on a computer system by obtaining a locale source file, in a preferred form, containing a plurality of elements having language and culture information, extracting and then using those elements and their associated values cooperatively with sample data, to generate readable text representations, thereby providing a country and language expert reviewer with textual data formatted according to the conventions embodied in the locale source file. <FOOTNOTE ID="FOO-00001">* ISO / IEC 9945-1:1900 (IEEE Standard 1003.2-1990) Information Technology-Portable Operating System Interface (POSIX(TM)) Shell Utilities, IEEE Standards 1003.2 and 1003.2a. < / FOOTNOTE> The invention provides representative results without requiring compilation of a locale object, thereby increasing the efficiency of validation efforts.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

An alternative to a real time operating system (RTOS) is provided based on serializing compilers. A serializing compiler can transform a multitasking application into an equivalent and optimized monolithic sequential code, to be compiled with the embedded processor's native optimizing compiler, effectively filling the RTOS gap. The serializing compiler can analyze the tasks at compile time and generate a fine-tuned, application specific infrastructure to support multitasking, resulting in a more efficient executable than one that is intended to run on top of a generic RTOS. By having control over the application execution and context switches, the serializing compiler enables the fine grain control of task timing while enhancing overall performance. The serializing compiler technology strengthens existing compilers, making them timing and task-aware. The Phantom compiler provides a fully automated mechanism to synthesize a single threaded, ANSI C / C++ program from a multithreaded C / C++ (extended with POSIX) program.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

A data object management scheme for storing a large plurality of small data objects (e.g., image files) in small number of large object stack file for storage in secondary storage (e.g., hard disks). By storing many individual data objects in a single object stack file, the number of files stored in the secondary storage is reduced by several orders of magnitude, from the billions or millions to the hundreds or so. Index data for each object stack file is generated and stored in primary storage to allow efficient and prompt access to the data objects. Requests to store or retrieve the data objects are made using HTTP messages including file identifiers that identify the files storing the data objects and keys identifying the data objects. A file server stores or retrieves the data object from secondary storage of a file server without converting the requests to NSF or POSIX commands.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

A method for creating a specific POSIX style locale source file, on demand, suitable for compilation in a computer is provided the method comprising, receiving a request submitted for the specific POSIX style locale, and obtaining a plurality of localization values related to the specific POSIX style locale. Next, determining a category within the plurality of localization values and selecting process routines dependent upon the category, and then selectively extracting the category information. After extracting the category information is stored into a memory of the computer. A determination is made regarding more categories to process, which might result in processing the remaining categories, otherwise assembling the extracted information into the POSIX style locale source file. Assembling may entail addition of no files or files such as LC-CTYPE and LC_COLLATE to form a locale source suitable for compilation.

A method for realizing minimum privilege control in safety operation system includes providing layer mapping relation between user, role, DTE domain, power and function for said system; revising and adding core function relating to privilege, system interface, power and function management, power and function decision as well as power and function operation at operation system; providing power and function management command for application layer and revising initial session program of said system.

Techniques for porting operating systems of a first class whose representatives include operating systems implementing the POSIX standard to operating systems of a second class whose representatives include operating systems implementing the Win32 API. Processes belonging to operating systems of the first class are characterized by a single thread, parent-child relationships, and signal handlers that execute on the top of the stack; processes belonging to operating systems belonging to the second class have multiple threads, do not have parent-child relationships, and do not necessarily execute their signal handlers at the top of the stack. Techniques are disclosed for implementing signal handling as required for operating systems of the first class and providing a signal to a parent process of the first class when one of its child processes terminates. Processes of the second class adapted for implementing processes of the first class are disclosed, as well as implementations of the POSIX fork and exec functions using those processes.

The embodiment of the invention provides a coexistence processing method and a device for a kernel mode protocol stack and a user mode protocol stack, and belongs to the technical field of networks. The method comprises the following steps: taking over a socket related function of a system, and using an interface specification consistent with a POSIX standard; modifying the taken-over system socket related function, and modifying a socket function corresponding to the application program, so that a kernel mode protocol stack interface and a user mode protocol stack interface are unified; and according to a preset message transmission rule, selecting to use the kernel mode protocol stack or the user mode protocol stack to process a receiving and sending message of the application program. According to the coexistence processing method and the device for the kernel mode protocol stack and the user mode protocol stack, a kernel mode protocol stack interface and a user mode protocol stackinterface are unified, coexistence of a single application and multiple protocol stacks is achieved, for application programs needing to use the user mode protocol stacks, only simple interface replacement needs to be conducted according to the user mode protocol stacks, the application program source program transplantation workload is small, and the system performance is high.

Techniques for suspending a TCP three-way handshake, offering the partial connection to an L-7 application or module at a proxy to perform further processing, and then allowing the L-7 application or module to instruct the proxy's network kernel to perform various actions are described. In various embodiments these actions may include: silently dropping the connection, verbosely rejecting the connection, accepting and processing the connection locally, or forwarding the connection to another proxy or the original destination. This additional functionality is provided, in one particular embodiment, via extensions to the POSIX socket API.

The invention discloses a cross-file system permission control method, device and equipment and a storage medium. The method comprises the steps that mounting a network file system NFS-Ganasia v4 version service mounted on the client side; receiving an ACL extension attribute obtaining or setting request of the client, and converting the ACL extension attribute obtaining or setting request into alinux standard system calling request; packaging the calling request into a remote procedure calling function and sending the remote procedure calling function to a network file system server; when the calling request received by the server corresponds to the request for obtaining the ACL extension attribute, calling the distributed file system to obtain the authority control extension attribute;and when the call request corresponds to the request for setting the ACL extension attribute, calling the distributed file system to set the authority control extension attribute. In this way, NFS-canbe solved through the above steps. And the problem that the version of the Ganna v4 protocol cannot be compatible with the distributed file system POSIX ACL standard authority control list proposal is solved.

A method for creating a specific POSIX style locale source file, on demand, suitable for compilation in a computer is provided the method comprising, receiving a request submitted for the specific POSIX style locale, and obtaining a plurality of localization values related to the specific POSIX style locale. Next, determining a category within the plurality of localization values and selecting process routines dependent upon the category, and then selectively extracting the category information. After extracting the category information is stored into a memory of the computer. A determination is made regarding more categories to process, which might result in processing the remaining categories, otherwise assembling the extracted information into the POSIX style locale source file. Assembling may entail addition of no files or files such as LC-CTYPE and LC_COLLATE to form a locale source suitable for compilation.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

Techniques described herein relate to systems and methods of data storage, and more particularly to providing layering of file system functionality on an object interface. In certain embodiments, file system functionality may be layered on cloud object interfaces to provide cloud-based storage while allowing for functionality expected from a legacy applications. For instance, POSIX interfaces and semantics may be layered on cloud-based storage, while providing access to data in a manner consistent with file-based access with data organization in name hierarchies. Various embodiments also may provide for memory mapping of data so that memory map changes are reflected in persistent storage while ensuring consistency between memory map changes and writes. For example, by transforming a ZFS file system disk-based storage into ZFS cloud-based storage, the ZFS file system gains the elastic nature of cloud storage.

The invention discloses a system and a reading and writing method for realizing asynchronous input and output interface of a distributed file system. The system for realizing the asynchronous input and output interface of the distributed file system comprises a dynamic link library which is embedded in an application progress address space for running and provides the asynchronous input and output IO interface invoked by the application process, a memory sharing module which is connected with the dynamic link library in a communication way; the memory sharing module comprises at least one asynchronous input and output AIO control block; and the memory sharing module realizes the submission and completion of the asynchronous reading and writing requirement by the AIO control block. The method realizes asynchronous IO interface on the distributed file system by the memory sharing mechanism, solves the performance problem of the POSIX standard asynchronous IO interface, and improves the large throughout reading and writing performance of the distributed file system.

A method for generating a file object identifier. A computer allocates memory to store the identifier. The disk volume holding the file object, the disk block holding the file object, and the value of the offset within the disk block holding the file object are stored in the allocated memory. In one embodiment, the file object is a file, a directory, or a symbolic link. In another embodiment, the memory allocated is 32 bits. In yet another embodiment, the disk volume value is a 4-bit value. In still another embodiment, the disk block value is a 23-bit value. In another embodiment, the block offset value is a 5-bit value. In another embodiment, the offset within the disk block is a multiple of 128 byte increments. In one embodiment, the generated file object identifier is a PORTABLE OPERATING SYSTEM INTERFACE (POSIX) file serial number.

The embodiment of the invention provides a method and apparatus for implementing remote calling. The method comprises the following steps: adding RPC calling request information of a PHP process to apublic POSIX message queue, wherein the RPC calling request information carries a process ID of the PHP process; sending the RPC calling request information in the public POSIX message queue to a message relay server through a preset proxy service, so that the message relay server returns an RPC response message after executing the corresponding method calling, wherein the RPC response message carries the process ID of the PHP process; adding the RPC response message to a dedicated POSIX message queue corresponding to the PHP process according to the process ID; and extracting the RPC responsemessage from the dedicated POSIX message queue. By adoption of the method and apparatus, a non-blocking RPC calling mode is achieved, and compared with the traditional blocking RPC calling mode, theRPC calling performance is effectively improved.

The invention discloses a protection method for controlling the thread exception, comprising the steps as follows: the state information of the system process is obtained and keeping record of the process names controlling the thread exception; the correspondent process number of the process name is looked up according to the process name obtained; the thread corresponding to the process number is cleared away; and the process of the process name is created. The invention perfects the management of the POSIX multithread process; gets monitored the management thread that is not monitored originally and avoids the process exception that affects the client using caused by the management thread exception.

The invention relates to a method for uploading mass small files in a distributed storage system. The method comprises the steps of looking for a target file with a creation request by a client according to standard POSIX semanteme of an operation system; pre-creating files by a metadata server and establishing a file pool; aggregating management file metadata by utilizing the metadata server; and sorting the files through a kernel module and synchronously uploading the files in batch. Therefore, the problems of long creation delay and small amount of the small files are solved, the uploading rate is greatly increased, the hardware resource waste is reduced, and the cost is reduced.

An embodiment of the invention provides a permission setting method and a permission setting device for a file system. When an access permission semantic type of a father node is a permission root type, all child nodes of the father node inherit ACL (access control lists) permission of the father node, so that only setting of the ACL permission of the father node is needed. Since traversing all subdirectories or files under the father node to respectively set the ACL permission of each child node under the father node is avoided, directory tree ACL permission setting efficiency is improved; in addition, since only setting of the ACL permission of the father node is needed, repeated ACL permission setting of subdirectories and files under a directory corresponding to the father node is avoided, and storage space consumption is reduced. When semantic type parameters represent that the access permission semantic type of the father node is a self type, access permission of the father node does not affect the ACL permission of all child nodes after current permission setting of the father node, and thus, ACL permission setting of nodes in accordance with POSIX (portable operating system interface of UNIX) standard semantics can be realized.