Apple Inc.

Damien Pascal Sorresso

Ivan Krstic

Kevin James Van Vechten

Eric Brandon Tamura

Neil Gareth Crane

Richard L Hagy

Scott James Forstall

Gregory B Novick

Gregory R Chapman

John Joseph Iarocci

Gordon J Freedman

Jason Clay Beaver

Joseph Sokol, Jr

Richard Warren Schreyer

Pierre-Olivier J Martel

Daniel Andreas Steffen

Lionel Divyang Desai

Ian J Baird

Lucia Elena Ballard

Henry Graham Mason

Darren S Litzinger

Christopher Marcellino

Sophia Teutschler

Curtis Rothert

Charles Srisuwananukorn

Jainam Ashokkumar Shah

Vishal Patel

David B Myszewski

Eric Russell Clements

Joseph Sokol

Matthew G Waston

Thomas Brogan Duffy

Eric Albert

David William Goodwin

Dallas Blake De Atley

Cahya Adiansyah Masputra

Umesh Suresh Vaishampayan

Nicholas Joseph Circosta

James Michael Magee

Kevin J Lindeman

Eric J Albert

Thomas Brogan Duffy, Jr

Pavel Sokolov

Ivan Krstić

David P Remahl

Michael Van Milligan

Ryan A Williams

Ananthakrishna Ramesh

Justin S Hogg

Julien Oster

Patrick R Metcalfe

Robert J Kendall-Kuppe

Ezekiel T Runyon

Elliot C Liskin

Ryan Nielsen

Yoni Baron

David P Remahl, Jr

Yosen Lin

Eric S Harmon

Mitchell K Allison

Geoffrey McCormack

Richard J Cooper

Steven C Vittitoe

Zachariah J Riggle

Vivek Verma

Andrew T Whitehead

Enclosed herein are techniques for securely executing an application. A method can be implemented by an operating system of a computing device, where the computing device includes a file system volume that includes a first data structure, and the method includes the steps of (1) receiving a request to launch the application, where the request references an application archive file that includes a second data structure that: (i) defines an organization of a plurality of files associated with the application, and (ii) includes cryptographic information for verifying the plurality of files and the second data structure; (2) in response to receiving the request: determining whether the second data structure, the plurality of files, or both, are valid using the cryptographic information; and (3) in response to determining that the second data structure, the plurality of files, or both, are valid: associating the second data structure with the first data structure.

Techniques for managing software applications

Aspects and features include maintaining at least one auxiliary disk image on a computing device. Certain code that is aligned with the base operating system of the computing device resides in and is executed from the auxiliary disk image. In one example, a computing device receives an update asset and uses it to patch the auxiliary disk image. The computing device executes the updated code from the patched disk image without rebooting or otherwise restarting the base operating system. The existing auxiliary disk image may be replaced with the patched disk image in response to a reboot or some other event, or while executing the code in the patched disk image from memory.

Patching code aligned with an executing base operating system

The subject disclosure provides systems and methods for application-specific network data filtering. Application-specific network data filtering may be performed by a sandboxed process prior to providing the network data to an application to which the network data is directed. Any malicious or otherwise potentially harmful data that is included in the network data may be removed by the application-specific network data filter or may be allowed to corrupt the application specific network data filtering operations within the sandbox, thereby preventing the malicious or harmful data from affecting the application or other portions of an electronic device. In one or more implementations, a first process such as an application-specific network data filtering process may request allocation of memory for the first process from second process, such as an application, that is separate from a memory manager of the electronic device.

Application specific network data filtering

Representative embodiments set forth herein disclose techniques for implementing improved links between paths of one or more file systems. According to some embodiments, techniques are disclosed for establishing a system volume and a data volume within a container. According to other embodiments, techniques are disclosed for establishing a link from a source path of a system volume within a container to a target path of a data volume within the container. According to yet other embodiments, techniques are disclosed for determining whether to allow a file system operation on a data volume of a container based on at least determining whether a target path is associated with a reference to a source path.

Systems and methods for implementing improved links between paths of one or more file systems

In an embodiment, a system supports an external trust cache. That is, the trust cache is separate from the kernel image on the non-volatile storage in the system. During boot, the boot code may read the trust cache from the storage and write it to the working memory of the system (e.g. the Random Access Memory (RAM) forming the memory system in the system). The boot code may also validate the kernel image and write it to the memory system. The boot code may program a region register in the processor to define a region in the working memory that encompasses the kernel image and the trust cache, to protect the region from modification/tampering.

External trust cache

Techniques for handling security of an application and its extension are described. In one embodiment, an application manager of an operating system running within a data processing system launches an application in a first sandboxed environment based on a first security profile associated with the application. In response to receiving a request from the application for accessing a function of an application extension that is associated with the application, the application manager launches the application extension in a second sandboxed environment based on a second security profile associated with the application extension. The application manager is to individually enforce security and manage resources of the application and the application extension in the first and second sandboxed environments based on the first and second security profiles, respectively. The second security profile specifies resources fewer than the first security profile.

Method and apparatus for handling security of an application and its extension

Systems and methods are disclosed for logging encoded diagnostic information from a sequence of processing operations, the processing operations generated by an activity in a computing environment. Diagnostic information is tracked by activity, across process boundaries where the processes can be in computationally isolated, or 'sandboxed'. Within each process, diagnostic information for an activity is stored in an activity-specific buffer registered with a kernel in the computing environment. For each activity in the computing system, the kernel keeps a list of all processes that have performed, or are performing, a processing task of the activity. The kernel also keeps a reference to the activity-specific log buffers for the activity for each process associated with the activity. If a processing operation for an activity fails, all activity-specific logs from all processes that are associated with the activity can be collected. A report can be generated from the collected logs for the activity.

Activity tracing diagnostic systems and methods

When an application is launched, a framework scanning module scans a plurality of frameworks linked against by the application to generate a list of available services. When the application makes a request of a particular service, a service verification module compares the requested service to the list of available services and if the requested service is found in the list of available services, sends a signal to the application, the signal allowing access to the requested service for the application. Otherwise, access to the requested service is denied.

Dynamic service discovery

A method for resource management of a data processing system is described herein. According to one embodiment, a token is periodically pushed into a memory usage queue, where the token includes a timestamp indicating time entering the memory usage queue. The memory usage queue stores a plurality of memory page identifiers (IDs) identifying a plurality of memory pages currently allocated to a plurality of programs running within the data processing system. In response to a request to reduce memory usage, a token is popped from the memory usage queue. A timestamp of the popped token is then compared with current time to determine whether a memory usage reduction action should be performed.

Adaptive resource management of a data processing system

A method and apparatus of a device that changes the importance of a daemon process is described. In an exemplary embodiment, the device receives a message from a user process destined for daemon process, wherein the daemon process executes independently of the user process and the first daemon process communicates messages with other executing processes. The device further determines if the first message indicates that the importance of the first daemon process can be changed. If the first message indicates the importance of the first daemon process can be changed, the device changes the importance of the first daemon process. The device additionally forwards the first message to the first daemon process.

Adaptive process importance

A method is described for assisting execution of an application that is implemented with individual blocks of program code that are executable with separate processes. The method includes receiving an indication that a first of the blocks desires availability of a service provided by a second of the blocks. The method further includes, in response to the receipt of the indication, instantiating an instance of code to handle the delivery of inter process requests from the first block to the second block. The method further includes, in response to the instance of code receiving a first request from the first block for the service, instantiating the second block for execution with a different process than the first block's process. The method further includes detecting that the second block has no pending requests and has not, over a period of time, received any new requests, and, terminating the second block in response.

Automatic service lifecycle management

Services for a personal electronic device are provided through which a form of background processing or multitasking is supported. The disclosed services permit user applications to take advantage of background processing without significant negative consequences to a user's experience of the foreground process or the personal electronic device's power resources. To effect the disclosed multitasking, one or more of a number of operational restrictions may be enforced. By way of example, inactive network applications (e.g., VOIP applications) may be placed in a suspended state until a message is received targeting the application (e.g., an incoming phone call or a heartbeat needed message). The user application may be placed into the background state to respond to the message and then returned to the non-active state (e.g., if the message was a heartbeat needed) message or to the foreground state if appropriate (e.g., the user elects to answer the incoming call).

Opportunistic multitasking of VOIP applications

Growing community of inventors

San Francisco, CA, United States of America

Damien Pascal Sorresso