]> err.no Git - linux-2.6/blob - drivers/acpi/utilities/utobject.c
ACPICA: Fix to handle NULL package elements correctly
[linux-2.6] / drivers / acpi / utilities / utobject.c
1 /******************************************************************************
2  *
3  * Module Name: utobject - ACPI object create/delete/size/cache routines
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2007, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/acnamesp.h>
46 #include <acpi/amlcode.h>
47
48 #define _COMPONENT          ACPI_UTILITIES
49 ACPI_MODULE_NAME("utobject")
50
51 /* Local prototypes */
52 static acpi_status
53 acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
54                                acpi_size * obj_length);
55
56 static acpi_status
57 acpi_ut_get_package_object_size(union acpi_operand_object *obj,
58                                 acpi_size * obj_length);
59
60 static acpi_status
61 acpi_ut_get_element_length(u8 object_type,
62                            union acpi_operand_object *source_object,
63                            union acpi_generic_state *state, void *context);
64
65 /*******************************************************************************
66  *
67  * FUNCTION:    acpi_ut_create_internal_object_dbg
68  *
69  * PARAMETERS:  module_name         - Source file name of caller
70  *              line_number         - Line number of caller
71  *              component_id        - Component type of caller
72  *              Type                - ACPI Type of the new object
73  *
74  * RETURN:      A new internal object, null on failure
75  *
76  * DESCRIPTION: Create and initialize a new internal object.
77  *
78  * NOTE:        We always allocate the worst-case object descriptor because
79  *              these objects are cached, and we want them to be
80  *              one-size-satisifies-any-request.  This in itself may not be
81  *              the most memory efficient, but the efficiency of the object
82  *              cache should more than make up for this!
83  *
84  ******************************************************************************/
85
86 union acpi_operand_object *acpi_ut_create_internal_object_dbg(char *module_name,
87                                                               u32 line_number,
88                                                               u32 component_id,
89                                                               acpi_object_type
90                                                               type)
91 {
92         union acpi_operand_object *object;
93         union acpi_operand_object *second_object;
94
95         ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
96                                 acpi_ut_get_type_name(type));
97
98         /* Allocate the raw object descriptor */
99
100         object =
101             acpi_ut_allocate_object_desc_dbg(module_name, line_number,
102                                              component_id);
103         if (!object) {
104                 return_PTR(NULL);
105         }
106
107         switch (type) {
108         case ACPI_TYPE_REGION:
109         case ACPI_TYPE_BUFFER_FIELD:
110         case ACPI_TYPE_LOCAL_BANK_FIELD:
111
112                 /* These types require a secondary object */
113
114                 second_object = acpi_ut_allocate_object_desc_dbg(module_name,
115                                                                  line_number,
116                                                                  component_id);
117                 if (!second_object) {
118                         acpi_ut_delete_object_desc(object);
119                         return_PTR(NULL);
120                 }
121
122                 second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
123                 second_object->common.reference_count = 1;
124
125                 /* Link the second object to the first */
126
127                 object->common.next_object = second_object;
128                 break;
129
130         default:
131                 /* All others have no secondary object */
132                 break;
133         }
134
135         /* Save the object type in the object descriptor */
136
137         object->common.type = (u8) type;
138
139         /* Init the reference count */
140
141         object->common.reference_count = 1;
142
143         /* Any per-type initialization should go here */
144
145         return_PTR(object);
146 }
147
148 /*******************************************************************************
149  *
150  * FUNCTION:    acpi_ut_create_package_object
151  *
152  * PARAMETERS:  Count               - Number of package elements
153  *
154  * RETURN:      Pointer to a new Package object, null on failure
155  *
156  * DESCRIPTION: Create a fully initialized package object
157  *
158  ******************************************************************************/
159
160 union acpi_operand_object *acpi_ut_create_package_object(u32 count)
161 {
162         union acpi_operand_object *package_desc;
163         union acpi_operand_object **package_elements;
164
165         ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count);
166
167         /* Create a new Package object */
168
169         package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
170         if (!package_desc) {
171                 return_PTR(NULL);
172         }
173
174         /*
175          * Create the element array. Count+1 allows the array to be null
176          * terminated.
177          */
178         package_elements = ACPI_ALLOCATE_ZEROED((acpi_size)
179                                                 (count + 1) * sizeof(void *));
180         if (!package_elements) {
181                 acpi_ut_remove_reference(package_desc);
182                 return_PTR(NULL);
183         }
184
185         package_desc->package.count = count;
186         package_desc->package.elements = package_elements;
187         return_PTR(package_desc);
188 }
189
190 /*******************************************************************************
191  *
192  * FUNCTION:    acpi_ut_create_buffer_object
193  *
194  * PARAMETERS:  buffer_size            - Size of buffer to be created
195  *
196  * RETURN:      Pointer to a new Buffer object, null on failure
197  *
198  * DESCRIPTION: Create a fully initialized buffer object
199  *
200  ******************************************************************************/
201
202 union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
203 {
204         union acpi_operand_object *buffer_desc;
205         u8 *buffer = NULL;
206
207         ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
208
209         /* Create a new Buffer object */
210
211         buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
212         if (!buffer_desc) {
213                 return_PTR(NULL);
214         }
215
216         /* Create an actual buffer only if size > 0 */
217
218         if (buffer_size > 0) {
219
220                 /* Allocate the actual buffer */
221
222                 buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
223                 if (!buffer) {
224                         ACPI_ERROR((AE_INFO, "Could not allocate size %X",
225                                     (u32) buffer_size));
226                         acpi_ut_remove_reference(buffer_desc);
227                         return_PTR(NULL);
228                 }
229         }
230
231         /* Complete buffer object initialization */
232
233         buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
234         buffer_desc->buffer.pointer = buffer;
235         buffer_desc->buffer.length = (u32) buffer_size;
236
237         /* Return the new buffer descriptor */
238
239         return_PTR(buffer_desc);
240 }
241
242 /*******************************************************************************
243  *
244  * FUNCTION:    acpi_ut_create_string_object
245  *
246  * PARAMETERS:  string_size         - Size of string to be created. Does not
247  *                                    include NULL terminator, this is added
248  *                                    automatically.
249  *
250  * RETURN:      Pointer to a new String object
251  *
252  * DESCRIPTION: Create a fully initialized string object
253  *
254  ******************************************************************************/
255
256 union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
257 {
258         union acpi_operand_object *string_desc;
259         char *string;
260
261         ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
262
263         /* Create a new String object */
264
265         string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
266         if (!string_desc) {
267                 return_PTR(NULL);
268         }
269
270         /*
271          * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
272          * NOTE: Zero-length strings are NULL terminated
273          */
274         string = ACPI_ALLOCATE_ZEROED(string_size + 1);
275         if (!string) {
276                 ACPI_ERROR((AE_INFO, "Could not allocate size %X",
277                             (u32) string_size));
278                 acpi_ut_remove_reference(string_desc);
279                 return_PTR(NULL);
280         }
281
282         /* Complete string object initialization */
283
284         string_desc->string.pointer = string;
285         string_desc->string.length = (u32) string_size;
286
287         /* Return the new string descriptor */
288
289         return_PTR(string_desc);
290 }
291
292 /*******************************************************************************
293  *
294  * FUNCTION:    acpi_ut_valid_internal_object
295  *
296  * PARAMETERS:  Object              - Object to be validated
297  *
298  * RETURN:      TRUE if object is valid, FALSE otherwise
299  *
300  * DESCRIPTION: Validate a pointer to be an union acpi_operand_object
301  *
302  ******************************************************************************/
303
304 u8 acpi_ut_valid_internal_object(void *object)
305 {
306
307         ACPI_FUNCTION_NAME(ut_valid_internal_object);
308
309         /* Check for a null pointer */
310
311         if (!object) {
312                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "**** Null Object Ptr\n"));
313                 return (FALSE);
314         }
315
316         /* Check the descriptor type field */
317
318         switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
319         case ACPI_DESC_TYPE_OPERAND:
320
321                 /* The object appears to be a valid union acpi_operand_object    */
322
323                 return (TRUE);
324
325         default:
326                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
327                                   "%p is not not an ACPI operand obj [%s]\n",
328                                   object, acpi_ut_get_descriptor_name(object)));
329                 break;
330         }
331
332         return (FALSE);
333 }
334
335 /*******************************************************************************
336  *
337  * FUNCTION:    acpi_ut_allocate_object_desc_dbg
338  *
339  * PARAMETERS:  module_name         - Caller's module name (for error output)
340  *              line_number         - Caller's line number (for error output)
341  *              component_id        - Caller's component ID (for error output)
342  *
343  * RETURN:      Pointer to newly allocated object descriptor.  Null on error
344  *
345  * DESCRIPTION: Allocate a new object descriptor.  Gracefully handle
346  *              error conditions.
347  *
348  ******************************************************************************/
349
350 void *acpi_ut_allocate_object_desc_dbg(char *module_name,
351                                        u32 line_number, u32 component_id)
352 {
353         union acpi_operand_object *object;
354
355         ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
356
357         object = acpi_os_acquire_object(acpi_gbl_operand_cache);
358         if (!object) {
359                 ACPI_ERROR((module_name, line_number,
360                             "Could not allocate an object descriptor"));
361
362                 return_PTR(NULL);
363         }
364
365         /* Mark the descriptor type */
366
367         memset(object, 0, sizeof(union acpi_operand_object));
368         ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
369
370         ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
371                           object, (u32) sizeof(union acpi_operand_object)));
372
373         return_PTR(object);
374 }
375
376 /*******************************************************************************
377  *
378  * FUNCTION:    acpi_ut_delete_object_desc
379  *
380  * PARAMETERS:  Object          - An Acpi internal object to be deleted
381  *
382  * RETURN:      None.
383  *
384  * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
385  *
386  ******************************************************************************/
387
388 void acpi_ut_delete_object_desc(union acpi_operand_object *object)
389 {
390         ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
391
392         /* Object must be an union acpi_operand_object    */
393
394         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
395                 ACPI_ERROR((AE_INFO,
396                             "%p is not an ACPI Operand object [%s]", object,
397                             acpi_ut_get_descriptor_name(object)));
398                 return_VOID;
399         }
400
401         (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
402         return_VOID;
403 }
404
405 /*******************************************************************************
406  *
407  * FUNCTION:    acpi_ut_get_simple_object_size
408  *
409  * PARAMETERS:  internal_object    - An ACPI operand object
410  *              obj_length         - Where the length is returned
411  *
412  * RETURN:      Status
413  *
414  * DESCRIPTION: This function is called to determine the space required to
415  *              contain a simple object for return to an external user.
416  *
417  *              The length includes the object structure plus any additional
418  *              needed space.
419  *
420  ******************************************************************************/
421
422 static acpi_status
423 acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
424                                acpi_size * obj_length)
425 {
426         acpi_size length;
427         acpi_status status = AE_OK;
428
429         ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
430
431         /*
432          * Handle a null object (Could be a uninitialized package
433          * element -- which is legal)
434          */
435         if (!internal_object) {
436                 *obj_length = sizeof(union acpi_object);
437                 return_ACPI_STATUS(AE_OK);
438         }
439
440         /* Start with the length of the Acpi object */
441
442         length = sizeof(union acpi_object);
443
444         if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
445
446                 /* Object is a named object (reference), just return the length */
447
448                 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
449                 return_ACPI_STATUS(status);
450         }
451
452         /*
453          * The final length depends on the object type
454          * Strings and Buffers are packed right up against the parent object and
455          * must be accessed bytewise or there may be alignment problems on
456          * certain processors
457          */
458         switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
459         case ACPI_TYPE_STRING:
460
461                 length += (acpi_size) internal_object->string.length + 1;
462                 break;
463
464         case ACPI_TYPE_BUFFER:
465
466                 length += (acpi_size) internal_object->buffer.length;
467                 break;
468
469         case ACPI_TYPE_INTEGER:
470         case ACPI_TYPE_PROCESSOR:
471         case ACPI_TYPE_POWER:
472
473                 /* No extra data for these types */
474
475                 break;
476
477         case ACPI_TYPE_LOCAL_REFERENCE:
478
479                 switch (internal_object->reference.opcode) {
480                 case AML_INT_NAMEPATH_OP:
481
482                         /*
483                          * Get the actual length of the full pathname to this object.
484                          * The reference will be converted to the pathname to the object
485                          */
486                         length +=
487                             ACPI_ROUND_UP_TO_NATIVE_WORD
488                             (acpi_ns_get_pathname_length
489                              (internal_object->reference.node));
490                         break;
491
492                 default:
493
494                         /*
495                          * No other reference opcodes are supported.
496                          * Notably, Locals and Args are not supported, but this may be
497                          * required eventually.
498                          */
499                         ACPI_ERROR((AE_INFO,
500                                     "Unsupported Reference opcode=%X in object %p",
501                                     internal_object->reference.opcode,
502                                     internal_object));
503                         status = AE_TYPE;
504                         break;
505                 }
506                 break;
507
508         default:
509
510                 ACPI_ERROR((AE_INFO, "Unsupported type=%X in object %p",
511                             ACPI_GET_OBJECT_TYPE(internal_object),
512                             internal_object));
513                 status = AE_TYPE;
514                 break;
515         }
516
517         /*
518          * Account for the space required by the object rounded up to the next
519          * multiple of the machine word size.  This keeps each object aligned
520          * on a machine word boundary. (preventing alignment faults on some
521          * machines.)
522          */
523         *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
524         return_ACPI_STATUS(status);
525 }
526
527 /*******************************************************************************
528  *
529  * FUNCTION:    acpi_ut_get_element_length
530  *
531  * PARAMETERS:  acpi_pkg_callback
532  *
533  * RETURN:      Status
534  *
535  * DESCRIPTION: Get the length of one package element.
536  *
537  ******************************************************************************/
538
539 static acpi_status
540 acpi_ut_get_element_length(u8 object_type,
541                            union acpi_operand_object *source_object,
542                            union acpi_generic_state *state, void *context)
543 {
544         acpi_status status = AE_OK;
545         struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
546         acpi_size object_space;
547
548         switch (object_type) {
549         case ACPI_COPY_TYPE_SIMPLE:
550
551                 /*
552                  * Simple object - just get the size (Null object/entry is handled
553                  * here also) and sum it into the running package length
554                  */
555                 status =
556                     acpi_ut_get_simple_object_size(source_object,
557                                                    &object_space);
558                 if (ACPI_FAILURE(status)) {
559                         return (status);
560                 }
561
562                 info->length += object_space;
563                 break;
564
565         case ACPI_COPY_TYPE_PACKAGE:
566
567                 /* Package object - nothing much to do here, let the walk handle it */
568
569                 info->num_packages++;
570                 state->pkg.this_target_obj = NULL;
571                 break;
572
573         default:
574
575                 /* No other types allowed */
576
577                 return (AE_BAD_PARAMETER);
578         }
579
580         return (status);
581 }
582
583 /*******************************************************************************
584  *
585  * FUNCTION:    acpi_ut_get_package_object_size
586  *
587  * PARAMETERS:  internal_object     - An ACPI internal object
588  *              obj_length          - Where the length is returned
589  *
590  * RETURN:      Status
591  *
592  * DESCRIPTION: This function is called to determine the space required to
593  *              contain a package object for return to an external user.
594  *
595  *              This is moderately complex since a package contains other
596  *              objects including packages.
597  *
598  ******************************************************************************/
599
600 static acpi_status
601 acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
602                                 acpi_size * obj_length)
603 {
604         acpi_status status;
605         struct acpi_pkg_info info;
606
607         ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
608
609         info.length = 0;
610         info.object_space = 0;
611         info.num_packages = 1;
612
613         status = acpi_ut_walk_package_tree(internal_object, NULL,
614                                            acpi_ut_get_element_length, &info);
615         if (ACPI_FAILURE(status)) {
616                 return_ACPI_STATUS(status);
617         }
618
619         /*
620          * We have handled all of the objects in all levels of the package.
621          * just add the length of the package objects themselves.
622          * Round up to the next machine word.
623          */
624         info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
625             (acpi_size) info.num_packages;
626
627         /* Return the total package length */
628
629         *obj_length = info.length;
630         return_ACPI_STATUS(status);
631 }
632
633 /*******************************************************************************
634  *
635  * FUNCTION:    acpi_ut_get_object_size
636  *
637  * PARAMETERS:  internal_object     - An ACPI internal object
638  *              obj_length          - Where the length will be returned
639  *
640  * RETURN:      Status
641  *
642  * DESCRIPTION: This function is called to determine the space required to
643  *              contain an object for return to an API user.
644  *
645  ******************************************************************************/
646
647 acpi_status
648 acpi_ut_get_object_size(union acpi_operand_object *internal_object,
649                         acpi_size * obj_length)
650 {
651         acpi_status status;
652
653         ACPI_FUNCTION_ENTRY();
654
655         if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
656              ACPI_DESC_TYPE_OPERAND)
657             && (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE)) {
658                 status =
659                     acpi_ut_get_package_object_size(internal_object,
660                                                     obj_length);
661         } else {
662                 status =
663                     acpi_ut_get_simple_object_size(internal_object, obj_length);
664         }
665
666         return (status);
667 }