Print this page
7127 remove -Wno-missing-braces from Makefile.uts
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/hsfs/hsfs_rrip.c
+++ new/usr/src/uts/common/fs/hsfs/hsfs_rrip.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26 /*
27 27 * Rock Ridge extensions to the System Use Sharing protocol
28 28 * for the High Sierra filesystem
29 29 */
30 30
31 31 #include <sys/types.h>
32 32 #include <sys/t_lock.h>
33 33 #include <sys/param.h>
34 34 #include <sys/systm.h>
35 35 #include <sys/kmem.h>
36 36 #include <sys/signal.h>
37 37 #include <sys/user.h>
38 38 #include <sys/proc.h>
39 39 #include <sys/disp.h>
40 40 #include <sys/buf.h>
41 41 #include <sys/pathname.h>
42 42 #include <sys/vfs.h>
43 43 #include <sys/vnode.h>
44 44 #include <sys/file.h>
45 45 #include <sys/uio.h>
46 46 #include <sys/conf.h>
47 47 #include <sys/stat.h>
48 48 #include <sys/mode.h>
49 49 #include <sys/mkdev.h>
50 50 #include <sys/ddi.h>
51 51
52 52 #include <vm/page.h>
53 53
54 54 #include <sys/fs/hsfs_spec.h>
55 55 #include <sys/fs/hsfs_isospec.h>
56 56 #include <sys/fs/hsfs_node.h>
57 57 #include <sys/fs/hsfs_impl.h>
58 58 #include <sys/fs/hsfs_susp.h>
59 59 #include <sys/fs/hsfs_rrip.h>
60 60
61 61 #include <sys/statvfs.h>
62 62 #include <sys/mount.h>
63 63 #include <sys/swap.h>
64 64 #include <sys/errno.h>
65 65 #include <sys/debug.h>
66 66 #include "fs/fs_subr.h"
|
↓ open down ↓ |
66 lines elided |
↑ open up ↑ |
67 67 #include <sys/cmn_err.h>
68 68
69 69 static void form_time(int, uchar_t *, struct timeval *);
70 70 static void name_parse(int, uchar_t *, size_t, uchar_t *, int *,
71 71 ulong_t *, int);
72 72
73 73 /*
74 74 * Signature table for RRIP
75 75 */
76 76 ext_signature_t rrip_signature_table[ ] = {
77 - RRIP_CL, rrip_child_link,
78 - RRIP_NM, rrip_name,
79 - RRIP_PL, rrip_parent_link,
80 - RRIP_PN, rrip_dev_nodes,
81 - RRIP_PX, rrip_file_attr,
82 - RRIP_RE, rrip_reloc_dir,
83 - RRIP_RR, rrip_rock_ridge,
84 - RRIP_SL, rrip_sym_link,
85 - RRIP_TF, rrip_file_time,
86 - (char *)NULL, NULL
77 + { RRIP_CL, rrip_child_link },
78 + { RRIP_NM, rrip_name },
79 + { RRIP_PL, rrip_parent_link },
80 + { RRIP_PN, rrip_dev_nodes },
81 + { RRIP_PX, rrip_file_attr },
82 + { RRIP_RE, rrip_reloc_dir },
83 + { RRIP_RR, rrip_rock_ridge },
84 + { RRIP_SL, rrip_sym_link },
85 + { RRIP_TF, rrip_file_time },
86 + { NULL, NULL }
87 87 };
88 88
89 89
90 90 /*
91 91 * rrip_dev_nodes()
92 92 *
93 93 * sig_handler() for RRIP signature "PN"
94 94 *
95 95 * This function parses out the major and minor numbers from the "PN
96 96 * " SUF.
97 97 */
98 98 uchar_t *
99 99 rrip_dev_nodes(sig_args_t *sig_args_p)
100 100 {
101 101 uchar_t *pn_ptr = sig_args_p->SUF_ptr;
102 102 major_t major_dev = (major_t)RRIP_MAJOR(pn_ptr);
103 103 minor_t minor_dev = (minor_t)RRIP_MINOR(pn_ptr);
104 104
105 105 sig_args_p->hdp->r_dev = makedevice(major_dev, minor_dev);
106 106
107 107 return (pn_ptr + SUF_LEN(pn_ptr));
108 108 }
109 109
110 110 /*
111 111 * rrip_file_attr()
112 112 *
113 113 * sig_handler() for RRIP signature "PX"
114 114 *
115 115 * This function parses out the file attributes of a file from the "PX"
116 116 * SUF. The attributes is finds are : st_mode, st_nlink, st_uid,
117 117 * and st_gid.
118 118 */
119 119 uchar_t *
120 120 rrip_file_attr(sig_args_t *sig_args_p)
121 121 {
122 122 uchar_t *px_ptr = sig_args_p->SUF_ptr;
123 123 struct hs_direntry *hdp = sig_args_p->hdp;
124 124
125 125 hdp->mode = RRIP_MODE(px_ptr);
126 126 hdp->nlink = RRIP_NLINK(px_ptr);
127 127 hdp->uid = RRIP_UID(px_ptr);
128 128 hdp->gid = RRIP_GID(px_ptr);
129 129
130 130 if (SUF_LEN(px_ptr) >= RRIP_PX_SIZE)
131 131 hdp->inode = (ino64_t)RRIP_INO(px_ptr);
132 132 else
133 133 hdp->inode = 0;
134 134
135 135 hdp->type = IFTOVT(hdp->mode);
136 136
137 137 return (px_ptr + SUF_LEN(px_ptr));
138 138 }
139 139
140 140 /*
141 141 * rrip_file_time()
142 142 *
143 143 * support function for rrip_file_time()
144 144 *
145 145 * This function decides whether to parse the times in a long time form
146 146 * (17 bytes) or a short time form (7 bytes). These time formats are
147 147 * defined in the ISO 9660 specification.
148 148 */
149 149 static void
150 150 form_time(int time_length, uchar_t *file_time, struct timeval *tvp)
151 151 {
152 152 if (time_length == ISO_DATE_LEN)
153 153 hs_parse_longdate(file_time, tvp);
154 154 else
155 155 hs_parse_dirdate(file_time, tvp);
156 156
157 157 }
158 158
159 159 /*
160 160 * rrip_file_time()
161 161 *
162 162 * sig_handler() for RRIP signature RRIP_TF
163 163 *
164 164 * This function parses out the file time attributes of a file from the
165 165 * "TI" SUF. The times it parses are : st_mtime, st_atime and st_ctime.
166 166 *
167 167 * The function form_time is a support function only used in this
168 168 * function.
169 169 */
170 170 uchar_t *
171 171 rrip_file_time(sig_args_t *sig_args_p)
172 172 {
173 173 uchar_t *tf_ptr = sig_args_p->SUF_ptr;
174 174
175 175 if (IS_TIME_BIT_SET(RRIP_TF_FLAGS(tf_ptr), RRIP_TF_ACCESS_BIT)) {
176 176 form_time(RRIP_TF_TIME_LENGTH(tf_ptr),
177 177 RRIP_tf_access(tf_ptr),
178 178 &sig_args_p->hdp->adate);
179 179 }
180 180
181 181 if (IS_TIME_BIT_SET(RRIP_TF_FLAGS(tf_ptr), RRIP_TF_MODIFY_BIT)) {
182 182 form_time(RRIP_TF_TIME_LENGTH(tf_ptr), RRIP_tf_modify(tf_ptr),
183 183 &sig_args_p->hdp->mdate);
184 184 }
185 185
186 186 if (IS_TIME_BIT_SET(RRIP_TF_FLAGS(tf_ptr), RRIP_TF_ATTRIBUTES_BIT)) {
187 187 form_time(RRIP_TF_TIME_LENGTH(tf_ptr),
188 188 RRIP_tf_attributes(tf_ptr),
189 189 &sig_args_p->hdp->cdate);
190 190 }
191 191
192 192 return (tf_ptr + SUF_LEN(tf_ptr));
193 193 }
194 194
195 195
196 196
197 197 /*
198 198 * name_parse()
199 199 *
200 200 * This is a generic fuction used for sym links and filenames. The
201 201 * flags passed to it effect the way the name/component field is parsed.
202 202 *
203 203 * The return value will be the NAME_CONTINUE or NAME_CHANGE value.
204 204 *
205 205 */
206 206 static void
207 207 name_parse(
208 208 int rrip_flags, /* component/name flag */
209 209 uchar_t *SUA_string, /* string from SUA */
210 210 size_t SUA_string_len, /* length of SUA string */
211 211 uchar_t *dst, /* string to copy to */
212 212 int *dst_lenp, /* ptr to cur. str len */
213 213 ulong_t *name_flags_p, /* internal name flags */
214 214 int dst_size) /* limit dest string to */
215 215 /* this value */
216 216 {
217 217 size_t off;
218 218 size_t len;
219 219
220 220 if (IS_NAME_BIT_SET(rrip_flags, RRIP_NAME_ROOT))
221 221 dst[0] = 0;
222 222
223 223 if (IS_NAME_BIT_SET(rrip_flags, RRIP_NAME_CURRENT)) {
224 224 SUA_string = (uchar_t *)".";
225 225 SUA_string_len = 1;
226 226 }
227 227
228 228 if (IS_NAME_BIT_SET(rrip_flags, RRIP_NAME_PARENT)) {
229 229 SUA_string = (uchar_t *)"..";
230 230 SUA_string_len = 2;
231 231 }
232 232
233 233 /*
234 234 * XXX
235 235 * For now, ignore the following flags and return.
236 236 * have to figure out how to get host name in kernel.
237 237 * Unsure if this even should be done.
238 238 */
239 239 if (IS_NAME_BIT_SET(rrip_flags, RRIP_NAME_VOLROOT) ||
240 240 IS_NAME_BIT_SET(rrip_flags, RRIP_NAME_HOST)) {
241 241 cmn_err(CE_NOTE,
242 242 "VOLUME ROOT and NAME_HOST currently unsupported\n");
243 243 return;
244 244 }
245 245
246 246 /*
247 247 * strlcat() has two nice properties:
248 248 * - the size of the output buffer includes the trailing '\0'
249 249 * - we pass "total size" not "remaining size"
250 250 * It'd be the ideal candidate for this codeblock - make it:
251 251 *
252 252 * strlcat(dst, SUA_string,
253 253 * MIN(dstsize, strlen(dst) + SUA_string_len + 1));
254 254 *
255 255 * Unfortunately, strlcat() cannot deal with input strings
256 256 * that are not NULL-terminated - like SUA_string can be in
257 257 * our case here. So we can't use it :(
258 258 * Now strncat() doesn't work either - because it doesn't deal
259 259 * with strings for which the 'potential NULL-termination' isn't
260 260 * accessible - strncat(dst, NULL, 0) crashes although it copies
261 261 * nothing in any case. If the SUA ends on a mapping boundary,
262 262 * then telling strncat() to copy no more than the remaining bytes
263 263 * in the buffer is of no avail if there's no NULL byte in them.
264 264 *
265 265 * Hence - binary copy. What are all these str* funcs for ??
266 266 */
267 267 dst_size--; /* trailing '\0' */
268 268
269 269 off = strlen((char *)dst);
270 270 len = MIN(dst_size - off, SUA_string_len);
271 271 bcopy((char *)SUA_string, (char *)(dst + off), len);
272 272 dst[off + len] = '\0';
273 273 *dst_lenp = strlen((char *)dst);
274 274
275 275 if (IS_NAME_BIT_SET(rrip_flags, RRIP_NAME_CONTINUE))
276 276 SET_NAME_BIT(*(name_flags_p), RRIP_NAME_CONTINUE);
277 277 else
278 278 SET_NAME_BIT(*(name_flags_p), RRIP_NAME_CHANGE);
279 279
280 280 }
281 281
282 282 /*
283 283 * rrip_name()
284 284 *
285 285 * sig_handler() for RRIP signature RRIP_NM
286 286 *
287 287 * This function handles the name of the current file. It is case
288 288 * sensitive to whatever was put into the field and does NO
289 289 * translation. It will take whatever characters were in the field.
290 290 *
291 291 * Because the flags effect the way the name is parsed the same way
292 292 * that the sym_link component parsing is done, we will use the same
293 293 * function to do the actual parsing.
294 294 */
295 295 uchar_t *
296 296 rrip_name(sig_args_t *sig_args_p)
297 297 {
298 298 uchar_t *nm_ptr = sig_args_p->SUF_ptr;
299 299
300 300 if ((sig_args_p->name_p == (uchar_t *)NULL) ||
301 301 (sig_args_p->name_len_p == (int *)NULL))
302 302 goto end;
303 303 /*
304 304 * If we have a "." or ".." directory, we should not look for
305 305 * an alternate name
306 306 */
307 307 if (HDE_NAME_LEN(sig_args_p->dirp) == 1) {
308 308 if (*((char *)HDE_name(sig_args_p->dirp)) == '\0') {
309 309 (void) strcpy((char *)sig_args_p->name_p, ".");
310 310 *sig_args_p->name_len_p = 1;
311 311 goto end;
312 312 } else if (*((char *)HDE_name(sig_args_p->dirp)) == '\1') {
313 313 (void) strcpy((char *)sig_args_p->name_p, "..");
314 314 *sig_args_p->name_len_p = 2;
315 315 goto end;
316 316 }
317 317 }
318 318
319 319 name_parse((int)RRIP_NAME_FLAGS(nm_ptr), RRIP_name(nm_ptr),
320 320 (size_t)RRIP_NAME_LEN(nm_ptr), sig_args_p->name_p,
321 321 sig_args_p->name_len_p, &(sig_args_p->name_flags),
322 322 MAXNAMELEN);
323 323
324 324 end:
325 325 return (nm_ptr + SUF_LEN(nm_ptr));
326 326 }
327 327
328 328
329 329 /*
330 330 * rrip_sym_link()
331 331 *
332 332 * sig_handler() for RRIP signature RRIP_SL
333 333 *
334 334 * creates a symlink buffer to simulate sym_links.
335 335 */
336 336 uchar_t *
337 337 rrip_sym_link(sig_args_t *sig_args_p)
338 338 {
339 339 uchar_t *sl_ptr = sig_args_p->SUF_ptr;
340 340 uchar_t *comp_ptr;
341 341 char *tmp_sym_link;
342 342 struct hs_direntry *hdp = sig_args_p->hdp;
343 343 int sym_link_len;
344 344 char *sym_link;
345 345
346 346 if (hdp->type != VLNK)
347 347 goto end;
348 348
349 349 /*
350 350 * If the sym link has already been created, don't recreate it
351 351 */
352 352 if (IS_NAME_BIT_SET(sig_args_p->name_flags, RRIP_SYM_LINK_COMPLETE))
353 353 goto end;
354 354
355 355 sym_link = kmem_alloc(MAXPATHLEN + 1, KM_SLEEP);
356 356
357 357 /*
358 358 * If there is an original string put it into sym_link[], otherwise
359 359 * initialize sym_link[] to the empty string.
360 360 */
361 361 if (hdp->sym_link != (char *)NULL) {
362 362 sym_link_len = (int)strlen(strcpy(sym_link, hdp->sym_link));
363 363 } else {
364 364 sym_link[0] = '\0';
365 365 sym_link_len = 0;
366 366 }
367 367
368 368 /* for all components */
369 369 for (comp_ptr = RRIP_sl_comp(sl_ptr);
370 370 comp_ptr < (sl_ptr + SUF_LEN(sl_ptr));
371 371 comp_ptr += RRIP_COMP_LEN(comp_ptr)) {
372 372
373 373 name_parse((int)RRIP_COMP_FLAGS(comp_ptr),
374 374 RRIP_comp(comp_ptr),
375 375 (size_t)RRIP_COMP_NAME_LEN(comp_ptr), (uchar_t *)sym_link,
376 376 &sym_link_len, &(sig_args_p->name_flags),
377 377 MAXPATHLEN);
378 378
379 379 /*
380 380 * If the component is continued don't put a '/' in
381 381 * the pathname, but do NULL terminate it.
382 382 */
383 383 if (IS_NAME_BIT_SET(RRIP_COMP_FLAGS(comp_ptr),
384 384 RRIP_NAME_CONTINUE)) {
385 385 sym_link[sym_link_len] = '\0';
386 386 } else {
387 387 sym_link[sym_link_len] = '/';
388 388 sym_link[sym_link_len + 1] = '\0';
389 389
390 390 /* add 1 to sym_link_len for '/' */
391 391 sym_link_len++;
392 392 }
393 393
394 394 }
395 395
396 396 /*
397 397 * If we reached the end of the symbolic link, take out the
398 398 * last slash, but don't change ROOT "/" to an empty string.
399 399 */
400 400 if (!IS_NAME_BIT_SET(RRIP_SL_FLAGS(sl_ptr), RRIP_NAME_CONTINUE) &&
401 401 sym_link_len > 1 && sym_link[sym_link_len - 1] == '/')
402 402 sym_link[--sym_link_len] = '\0';
403 403
404 404 /*
405 405 * if no memory has been allocated, get some, otherwise, append
406 406 * to the current allocation
407 407 */
408 408
409 409 tmp_sym_link = kmem_alloc(SYM_LINK_LEN(sym_link), KM_SLEEP);
410 410
411 411 (void) strcpy(tmp_sym_link, sym_link);
412 412
413 413 if (hdp->sym_link != (char *)NULL)
414 414 kmem_free(hdp->sym_link, (size_t)(hdp->ext_size + 1));
415 415
416 416 hdp->sym_link = (char *)&tmp_sym_link[0];
417 417 /* the size of a symlink is its length */
418 418 hdp->ext_size = (uint_t)strlen(tmp_sym_link);
419 419
420 420 if (!IS_NAME_BIT_SET(RRIP_SL_FLAGS(sl_ptr), RRIP_NAME_CONTINUE)) {
421 421 /* reached the end of the symbolic link */
422 422 SET_NAME_BIT(sig_args_p->name_flags, RRIP_SYM_LINK_COMPLETE);
423 423 }
424 424
425 425 kmem_free(sym_link, MAXPATHLEN + 1);
426 426 end:
427 427 return (sl_ptr + SUF_LEN(sl_ptr));
428 428 }
429 429
430 430 /*
431 431 * rrip_namecopy()
432 432 *
433 433 * This function will copy the rrip name to the "to" buffer, if it
434 434 * exists.
435 435 *
436 436 * XXX - We should speed this up by implementing the search in
437 437 * parse_sua(). It works right now, so I don't want to mess with it.
438 438 */
439 439 int
440 440 rrip_namecopy(
441 441 char *from, /* name to copy */
442 442 char *to, /* string to copy "from" to */
443 443 char *tmp_name, /* temp storage for original name */
444 444 uchar_t *dirp, /* directory entry pointer */
445 445 uint_t last_offset, /* last index into current dir block */
446 446 struct hsfs *fsp, /* filesystem pointer */
447 447 struct hs_direntry *hdp) /* directory entry pointer to put */
448 448 /* all that good info in */
449 449 {
450 450 int size = 0;
451 451 int change_flag = 0;
452 452 int ret_val;
453 453
454 454 if ((to == (char *)NULL) ||
455 455 (from == (char *)NULL) ||
456 456 (dirp == (uchar_t *)NULL)) {
457 457 return (0);
458 458 }
459 459
460 460 /* special handling for '.' and '..' */
461 461
462 462 if (HDE_NAME_LEN(dirp) == 1) {
463 463 if (*((char *)HDE_name(dirp)) == '\0') {
464 464 (void) strcpy(to, ".");
465 465 return (1);
466 466 } else if (*((char *)HDE_name(dirp)) == '\1') {
467 467 (void) strcpy(to, "..");
468 468 return (2);
469 469 }
470 470 }
471 471
472 472
473 473 ret_val = parse_sua((uchar_t *)to, &size, &change_flag,
474 474 dirp, last_offset,
475 475 hdp, fsp, (uchar_t *)NULL, NULL);
476 476
477 477 if (IS_NAME_BIT_SET(change_flag, RRIP_NAME_CHANGE) && !ret_val)
478 478 return (size);
479 479
480 480 /*
481 481 * Well, the name was not found
482 482 *
483 483 * make rripname an upper case "nm" (to), so that
484 484 * we can compare it the current HDE_DIR_NAME()
485 485 * without nuking the original "nm", for future case
486 486 * sensitive name comparing
487 487 */
488 488 (void) strcpy(tmp_name, from); /* keep original */
489 489 size = hs_uppercase_copy(tmp_name, from, (int)strlen(from));
490 490
491 491 return (-1);
492 492 }
493 493
494 494
495 495
496 496 /*
497 497 * rrip_reloc_dir()
498 498 *
499 499 * This function is fairly bogus. All it does is cause a failure of
500 500 * the hs_parsedir, so that no vnode will be made for it and
501 501 * essentially, the directory will no longer be seen. This is part
502 502 * of the directory hierarchy mess, where the relocated directory will
503 503 * be hidden as far as ISO 9660 is concerned. When we hit the child
504 504 * link "CL" SUF, then we will read the new directory.
505 505 */
506 506 uchar_t *
507 507 rrip_reloc_dir(sig_args_t *sig_args_p)
508 508 {
509 509 uchar_t *re_ptr = sig_args_p->SUF_ptr;
510 510
511 511 sig_args_p->flags = RELOC_DIR;
512 512
513 513 return (re_ptr + SUF_LEN(re_ptr));
514 514 }
515 515
516 516
517 517
518 518 /*
519 519 * rrip_child_link()
520 520 *
521 521 * This is the child link part of the directory hierarchy stuff and
522 522 * this does not really do much anyway. All it does is read the
523 523 * directory entry that the child link SUF contains. All should be
524 524 * fine then.
525 525 */
526 526 uchar_t *
527 527 rrip_child_link(sig_args_t *sig_args_p)
528 528 {
529 529 uchar_t *cl_ptr = sig_args_p->SUF_ptr;
530 530
531 531 sig_args_p->hdp->ext_lbn = RRIP_CHILD_LBN(cl_ptr);
532 532
533 533 hs_filldirent(sig_args_p->fsp->hsfs_rootvp, sig_args_p->hdp);
534 534
535 535 sig_args_p->flags = 0;
536 536
537 537 return (cl_ptr + SUF_LEN(cl_ptr));
538 538 }
539 539
540 540
541 541 /*
542 542 * rrip_parent_link()
543 543 *
544 544 * This is the parent link part of the directory hierarchy stuff and
545 545 * this does not really do much anyway. All it does is read the
546 546 * directory entry that the parent link SUF contains. All should be
547 547 * fine then.
548 548 */
549 549 uchar_t *
550 550 rrip_parent_link(sig_args_t *sig_args_p)
551 551 {
552 552 uchar_t *pl_ptr = sig_args_p->SUF_ptr;
553 553
554 554 sig_args_p->hdp->ext_lbn = RRIP_PARENT_LBN(pl_ptr);
555 555
556 556 hs_filldirent(sig_args_p->fsp->hsfs_rootvp, sig_args_p->hdp);
557 557
558 558 sig_args_p->flags = 0;
559 559
560 560 return (pl_ptr + SUF_LEN(pl_ptr));
561 561 }
562 562
563 563
564 564 /*
565 565 * rrip_rock_ridge()
566 566 *
567 567 * This function is supposed to aid in speed of the filesystem.
568 568 *
569 569 * XXX - It is only here as a place holder so far.
570 570 */
571 571 uchar_t *
572 572 rrip_rock_ridge(sig_args_t *sig_args_p)
573 573 {
574 574 uchar_t *rr_ptr = sig_args_p->SUF_ptr;
575 575
576 576 return (rr_ptr + SUF_LEN(rr_ptr));
577 577 }
|
↓ open down ↓ |
481 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX