namei.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525
  1. /*
  2. * namei.c - NTFS kernel directory inode operations. Part of the Linux-NTFS
  3. * project.
  4. *
  5. * Copyright (c) 2001-2006 Anton Altaparmakov
  6. *
  7. * This program/include file is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License as published
  9. * by the Free Software Foundation; either version 2 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * This program/include file is distributed in the hope that it will be
  13. * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  14. * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program (in the main directory of the Linux-NTFS
  19. * distribution in the file COPYING); if not, write to the Free Software
  20. * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. */
  22. #include <linux/dcache.h>
  23. #include <linux/security.h>
  24. #include "attrib.h"
  25. #include "debug.h"
  26. #include "dir.h"
  27. #include "mft.h"
  28. #include "ntfs.h"
  29. /**
  30. * ntfs_lookup - find the inode represented by a dentry in a directory inode
  31. * @dir_ino: directory inode in which to look for the inode
  32. * @dent: dentry representing the inode to look for
  33. * @nd: lookup nameidata
  34. *
  35. * In short, ntfs_lookup() looks for the inode represented by the dentry @dent
  36. * in the directory inode @dir_ino and if found attaches the inode to the
  37. * dentry @dent.
  38. *
  39. * In more detail, the dentry @dent specifies which inode to look for by
  40. * supplying the name of the inode in @dent->d_name.name. ntfs_lookup()
  41. * converts the name to Unicode and walks the contents of the directory inode
  42. * @dir_ino looking for the converted Unicode name. If the name is found in the
  43. * directory, the corresponding inode is loaded by calling ntfs_iget() on its
  44. * inode number and the inode is associated with the dentry @dent via a call to
  45. * d_splice_alias().
  46. *
  47. * If the name is not found in the directory, a NULL inode is inserted into the
  48. * dentry @dent via a call to d_add(). The dentry is then termed a negative
  49. * dentry.
  50. *
  51. * Only if an actual error occurs, do we return an error via ERR_PTR().
  52. *
  53. * In order to handle the case insensitivity issues of NTFS with regards to the
  54. * dcache and the dcache requiring only one dentry per directory, we deal with
  55. * dentry aliases that only differ in case in ->ntfs_lookup() while maintaining
  56. * a case sensitive dcache. This means that we get the full benefit of dcache
  57. * speed when the file/directory is looked up with the same case as returned by
  58. * ->ntfs_readdir() but that a lookup for any other case (or for the short file
  59. * name) will not find anything in dcache and will enter ->ntfs_lookup()
  60. * instead, where we search the directory for a fully matching file name
  61. * (including case) and if that is not found, we search for a file name that
  62. * matches with different case and if that has non-POSIX semantics we return
  63. * that. We actually do only one search (case sensitive) and keep tabs on
  64. * whether we have found a case insensitive match in the process.
  65. *
  66. * To simplify matters for us, we do not treat the short vs long filenames as
  67. * two hard links but instead if the lookup matches a short filename, we
  68. * return the dentry for the corresponding long filename instead.
  69. *
  70. * There are three cases we need to distinguish here:
  71. *
  72. * 1) @dent perfectly matches (i.e. including case) a directory entry with a
  73. * file name in the WIN32 or POSIX namespaces. In this case
  74. * ntfs_lookup_inode_by_name() will return with name set to NULL and we
  75. * just d_splice_alias() @dent.
  76. * 2) @dent matches (not including case) a directory entry with a file name in
  77. * the WIN32 namespace. In this case ntfs_lookup_inode_by_name() will return
  78. * with name set to point to a kmalloc()ed ntfs_name structure containing
  79. * the properly cased little endian Unicode name. We convert the name to the
  80. * current NLS code page, search if a dentry with this name already exists
  81. * and if so return that instead of @dent. At this point things are
  82. * complicated by the possibility of 'disconnected' dentries due to NFS
  83. * which we deal with appropriately (see the code comments). The VFS will
  84. * then destroy the old @dent and use the one we returned. If a dentry is
  85. * not found, we allocate a new one, d_splice_alias() it, and return it as
  86. * above.
  87. * 3) @dent matches either perfectly or not (i.e. we don't care about case) a
  88. * directory entry with a file name in the DOS namespace. In this case
  89. * ntfs_lookup_inode_by_name() will return with name set to point to a
  90. * kmalloc()ed ntfs_name structure containing the mft reference (cpu endian)
  91. * of the inode. We use the mft reference to read the inode and to find the
  92. * file name in the WIN32 namespace corresponding to the matched short file
  93. * name. We then convert the name to the current NLS code page, and proceed
  94. * searching for a dentry with this name, etc, as in case 2), above.
  95. *
  96. * Locking: Caller must hold i_mutex on the directory.
  97. */
  98. static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent,
  99. struct nameidata *nd)
  100. {
  101. ntfs_volume *vol = NTFS_SB(dir_ino->i_sb);
  102. struct inode *dent_inode;
  103. ntfschar *uname;
  104. ntfs_name *name = NULL;
  105. MFT_REF mref;
  106. unsigned long dent_ino;
  107. int uname_len;
  108. ntfs_debug("Looking up %s in directory inode 0x%lx.",
  109. dent->d_name.name, dir_ino->i_ino);
  110. /* Convert the name of the dentry to Unicode. */
  111. uname_len = ntfs_nlstoucs(vol, dent->d_name.name, dent->d_name.len,
  112. &uname);
  113. if (uname_len < 0) {
  114. if (uname_len != -ENAMETOOLONG)
  115. ntfs_error(vol->sb, "Failed to convert name to "
  116. "Unicode.");
  117. return ERR_PTR(uname_len);
  118. }
  119. mref = ntfs_lookup_inode_by_name(NTFS_I(dir_ino), uname, uname_len,
  120. &name);
  121. kmem_cache_free(ntfs_name_cache, uname);
  122. if (!IS_ERR_MREF(mref)) {
  123. dent_ino = MREF(mref);
  124. ntfs_debug("Found inode 0x%lx. Calling ntfs_iget.", dent_ino);
  125. dent_inode = ntfs_iget(vol->sb, dent_ino);
  126. if (likely(!IS_ERR(dent_inode))) {
  127. /* Consistency check. */
  128. if (is_bad_inode(dent_inode) || MSEQNO(mref) ==
  129. NTFS_I(dent_inode)->seq_no ||
  130. dent_ino == FILE_MFT) {
  131. /* Perfect WIN32/POSIX match. -- Case 1. */
  132. if (!name) {
  133. ntfs_debug("Done. (Case 1.)");
  134. return d_splice_alias(dent_inode, dent);
  135. }
  136. /*
  137. * We are too indented. Handle imperfect
  138. * matches and short file names further below.
  139. */
  140. goto handle_name;
  141. }
  142. ntfs_error(vol->sb, "Found stale reference to inode "
  143. "0x%lx (reference sequence number = "
  144. "0x%x, inode sequence number = 0x%x), "
  145. "returning -EIO. Run chkdsk.",
  146. dent_ino, MSEQNO(mref),
  147. NTFS_I(dent_inode)->seq_no);
  148. iput(dent_inode);
  149. dent_inode = ERR_PTR(-EIO);
  150. } else
  151. ntfs_error(vol->sb, "ntfs_iget(0x%lx) failed with "
  152. "error code %li.", dent_ino,
  153. PTR_ERR(dent_inode));
  154. kfree(name);
  155. /* Return the error code. */
  156. return (struct dentry *)dent_inode;
  157. }
  158. /* It is guaranteed that @name is no longer allocated at this point. */
  159. if (MREF_ERR(mref) == -ENOENT) {
  160. ntfs_debug("Entry was not found, adding negative dentry.");
  161. /* The dcache will handle negative entries. */
  162. d_add(dent, NULL);
  163. ntfs_debug("Done.");
  164. return NULL;
  165. }
  166. ntfs_error(vol->sb, "ntfs_lookup_ino_by_name() failed with error "
  167. "code %i.", -MREF_ERR(mref));
  168. return ERR_PTR(MREF_ERR(mref));
  169. // TODO: Consider moving this lot to a separate function! (AIA)
  170. handle_name:
  171. {
  172. struct dentry *real_dent, *new_dent;
  173. MFT_RECORD *m;
  174. ntfs_attr_search_ctx *ctx;
  175. ntfs_inode *ni = NTFS_I(dent_inode);
  176. int err;
  177. struct qstr nls_name;
  178. nls_name.name = NULL;
  179. if (name->type != FILE_NAME_DOS) { /* Case 2. */
  180. ntfs_debug("Case 2.");
  181. nls_name.len = (unsigned)ntfs_ucstonls(vol,
  182. (ntfschar*)&name->name, name->len,
  183. (unsigned char**)&nls_name.name, 0);
  184. kfree(name);
  185. } else /* if (name->type == FILE_NAME_DOS) */ { /* Case 3. */
  186. FILE_NAME_ATTR *fn;
  187. ntfs_debug("Case 3.");
  188. kfree(name);
  189. /* Find the WIN32 name corresponding to the matched DOS name. */
  190. ni = NTFS_I(dent_inode);
  191. m = map_mft_record(ni);
  192. if (IS_ERR(m)) {
  193. err = PTR_ERR(m);
  194. m = NULL;
  195. ctx = NULL;
  196. goto err_out;
  197. }
  198. ctx = ntfs_attr_get_search_ctx(ni, m);
  199. if (unlikely(!ctx)) {
  200. err = -ENOMEM;
  201. goto err_out;
  202. }
  203. do {
  204. ATTR_RECORD *a;
  205. u32 val_len;
  206. err = ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, 0, 0,
  207. NULL, 0, ctx);
  208. if (unlikely(err)) {
  209. ntfs_error(vol->sb, "Inode corrupt: No WIN32 "
  210. "namespace counterpart to DOS "
  211. "file name. Run chkdsk.");
  212. if (err == -ENOENT)
  213. err = -EIO;
  214. goto err_out;
  215. }
  216. /* Consistency checks. */
  217. a = ctx->attr;
  218. if (a->non_resident || a->flags)
  219. goto eio_err_out;
  220. val_len = le32_to_cpu(a->data.resident.value_length);
  221. if (le16_to_cpu(a->data.resident.value_offset) +
  222. val_len > le32_to_cpu(a->length))
  223. goto eio_err_out;
  224. fn = (FILE_NAME_ATTR*)((u8*)ctx->attr + le16_to_cpu(
  225. ctx->attr->data.resident.value_offset));
  226. if ((u32)(fn->file_name_length * sizeof(ntfschar) +
  227. sizeof(FILE_NAME_ATTR)) > val_len)
  228. goto eio_err_out;
  229. } while (fn->file_name_type != FILE_NAME_WIN32);
  230. /* Convert the found WIN32 name to current NLS code page. */
  231. nls_name.len = (unsigned)ntfs_ucstonls(vol,
  232. (ntfschar*)&fn->file_name, fn->file_name_length,
  233. (unsigned char**)&nls_name.name, 0);
  234. ntfs_attr_put_search_ctx(ctx);
  235. unmap_mft_record(ni);
  236. }
  237. m = NULL;
  238. ctx = NULL;
  239. /* Check if a conversion error occurred. */
  240. if ((signed)nls_name.len < 0) {
  241. err = (signed)nls_name.len;
  242. goto err_out;
  243. }
  244. nls_name.hash = full_name_hash(nls_name.name, nls_name.len);
  245. /*
  246. * Note: No need for dent->d_lock lock as i_mutex is held on the
  247. * parent inode.
  248. */
  249. /* Does a dentry matching the nls_name exist already? */
  250. real_dent = d_lookup(dent->d_parent, &nls_name);
  251. /* If not, create it now. */
  252. if (!real_dent) {
  253. real_dent = d_alloc(dent->d_parent, &nls_name);
  254. kfree(nls_name.name);
  255. if (!real_dent) {
  256. err = -ENOMEM;
  257. goto err_out;
  258. }
  259. new_dent = d_splice_alias(dent_inode, real_dent);
  260. if (new_dent)
  261. dput(real_dent);
  262. else
  263. new_dent = real_dent;
  264. ntfs_debug("Done. (Created new dentry.)");
  265. return new_dent;
  266. }
  267. kfree(nls_name.name);
  268. /* Matching dentry exists, check if it is negative. */
  269. if (real_dent->d_inode) {
  270. if (unlikely(real_dent->d_inode != dent_inode)) {
  271. /* This can happen because bad inodes are unhashed. */
  272. BUG_ON(!is_bad_inode(dent_inode));
  273. BUG_ON(!is_bad_inode(real_dent->d_inode));
  274. }
  275. /*
  276. * Already have the inode and the dentry attached, decrement
  277. * the reference count to balance the ntfs_iget() we did
  278. * earlier on. We found the dentry using d_lookup() so it
  279. * cannot be disconnected and thus we do not need to worry
  280. * about any NFS/disconnectedness issues here.
  281. */
  282. iput(dent_inode);
  283. ntfs_debug("Done. (Already had inode and dentry.)");
  284. return real_dent;
  285. }
  286. /*
  287. * Negative dentry: instantiate it unless the inode is a directory and
  288. * has a 'disconnected' dentry (i.e. IS_ROOT and DCACHE_DISCONNECTED),
  289. * in which case d_move() that in place of the found dentry.
  290. */
  291. if (!S_ISDIR(dent_inode->i_mode)) {
  292. /* Not a directory; everything is easy. */
  293. d_instantiate(real_dent, dent_inode);
  294. ntfs_debug("Done. (Already had negative file dentry.)");
  295. return real_dent;
  296. }
  297. spin_lock(&dcache_lock);
  298. if (list_empty(&dent_inode->i_dentry)) {
  299. /*
  300. * Directory without a 'disconnected' dentry; we need to do
  301. * d_instantiate() by hand because it takes dcache_lock which
  302. * we already hold.
  303. */
  304. list_add(&real_dent->d_alias, &dent_inode->i_dentry);
  305. real_dent->d_inode = dent_inode;
  306. spin_unlock(&dcache_lock);
  307. security_d_instantiate(real_dent, dent_inode);
  308. ntfs_debug("Done. (Already had negative directory dentry.)");
  309. return real_dent;
  310. }
  311. /*
  312. * Directory with a 'disconnected' dentry; get a reference to the
  313. * 'disconnected' dentry.
  314. */
  315. new_dent = list_entry(dent_inode->i_dentry.next, struct dentry,
  316. d_alias);
  317. dget_locked(new_dent);
  318. spin_unlock(&dcache_lock);
  319. /* Do security vodoo. */
  320. security_d_instantiate(real_dent, dent_inode);
  321. /* Move new_dent in place of real_dent. */
  322. d_move(new_dent, real_dent);
  323. /* Balance the ntfs_iget() we did above. */
  324. iput(dent_inode);
  325. /* Throw away real_dent. */
  326. dput(real_dent);
  327. /* Use new_dent as the actual dentry. */
  328. ntfs_debug("Done. (Already had negative, disconnected directory "
  329. "dentry.)");
  330. return new_dent;
  331. eio_err_out:
  332. ntfs_error(vol->sb, "Illegal file name attribute. Run chkdsk.");
  333. err = -EIO;
  334. err_out:
  335. if (ctx)
  336. ntfs_attr_put_search_ctx(ctx);
  337. if (m)
  338. unmap_mft_record(ni);
  339. iput(dent_inode);
  340. ntfs_error(vol->sb, "Failed, returning error code %i.", err);
  341. return ERR_PTR(err);
  342. }
  343. }
  344. /**
  345. * Inode operations for directories.
  346. */
  347. const struct inode_operations ntfs_dir_inode_ops = {
  348. .lookup = ntfs_lookup, /* VFS: Lookup directory. */
  349. };
  350. /**
  351. * ntfs_get_parent - find the dentry of the parent of a given directory dentry
  352. * @child_dent: dentry of the directory whose parent directory to find
  353. *
  354. * Find the dentry for the parent directory of the directory specified by the
  355. * dentry @child_dent. This function is called from
  356. * fs/exportfs/expfs.c::find_exported_dentry() which in turn is called from the
  357. * default ->decode_fh() which is export_decode_fh() in the same file.
  358. *
  359. * The code is based on the ext3 ->get_parent() implementation found in
  360. * fs/ext3/namei.c::ext3_get_parent().
  361. *
  362. * Note: ntfs_get_parent() is called with @child_dent->d_inode->i_mutex down.
  363. *
  364. * Return the dentry of the parent directory on success or the error code on
  365. * error (IS_ERR() is true).
  366. */
  367. static struct dentry *ntfs_get_parent(struct dentry *child_dent)
  368. {
  369. struct inode *vi = child_dent->d_inode;
  370. ntfs_inode *ni = NTFS_I(vi);
  371. MFT_RECORD *mrec;
  372. ntfs_attr_search_ctx *ctx;
  373. ATTR_RECORD *attr;
  374. FILE_NAME_ATTR *fn;
  375. struct inode *parent_vi;
  376. struct dentry *parent_dent;
  377. unsigned long parent_ino;
  378. int err;
  379. ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
  380. /* Get the mft record of the inode belonging to the child dentry. */
  381. mrec = map_mft_record(ni);
  382. if (IS_ERR(mrec))
  383. return (struct dentry *)mrec;
  384. /* Find the first file name attribute in the mft record. */
  385. ctx = ntfs_attr_get_search_ctx(ni, mrec);
  386. if (unlikely(!ctx)) {
  387. unmap_mft_record(ni);
  388. return ERR_PTR(-ENOMEM);
  389. }
  390. try_next:
  391. err = ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, CASE_SENSITIVE, 0, NULL,
  392. 0, ctx);
  393. if (unlikely(err)) {
  394. ntfs_attr_put_search_ctx(ctx);
  395. unmap_mft_record(ni);
  396. if (err == -ENOENT)
  397. ntfs_error(vi->i_sb, "Inode 0x%lx does not have a "
  398. "file name attribute. Run chkdsk.",
  399. vi->i_ino);
  400. return ERR_PTR(err);
  401. }
  402. attr = ctx->attr;
  403. if (unlikely(attr->non_resident))
  404. goto try_next;
  405. fn = (FILE_NAME_ATTR *)((u8 *)attr +
  406. le16_to_cpu(attr->data.resident.value_offset));
  407. if (unlikely((u8 *)fn + le32_to_cpu(attr->data.resident.value_length) >
  408. (u8*)attr + le32_to_cpu(attr->length)))
  409. goto try_next;
  410. /* Get the inode number of the parent directory. */
  411. parent_ino = MREF_LE(fn->parent_directory);
  412. /* Release the search context and the mft record of the child. */
  413. ntfs_attr_put_search_ctx(ctx);
  414. unmap_mft_record(ni);
  415. /* Get the inode of the parent directory. */
  416. parent_vi = ntfs_iget(vi->i_sb, parent_ino);
  417. if (IS_ERR(parent_vi) || unlikely(is_bad_inode(parent_vi))) {
  418. if (!IS_ERR(parent_vi))
  419. iput(parent_vi);
  420. ntfs_error(vi->i_sb, "Failed to get parent directory inode "
  421. "0x%lx of child inode 0x%lx.", parent_ino,
  422. vi->i_ino);
  423. return ERR_PTR(-EACCES);
  424. }
  425. /* Finally get a dentry for the parent directory and return it. */
  426. parent_dent = d_alloc_anon(parent_vi);
  427. if (unlikely(!parent_dent)) {
  428. iput(parent_vi);
  429. return ERR_PTR(-ENOMEM);
  430. }
  431. ntfs_debug("Done for inode 0x%lx.", vi->i_ino);
  432. return parent_dent;
  433. }
  434. /**
  435. * ntfs_get_dentry - find a dentry for the inode from a file handle sub-fragment
  436. * @sb: super block identifying the mounted ntfs volume
  437. * @fh: the file handle sub-fragment
  438. *
  439. * Find a dentry for the inode given a file handle sub-fragment. This function
  440. * is called from fs/exportfs/expfs.c::find_exported_dentry() which in turn is
  441. * called from the default ->decode_fh() which is export_decode_fh() in the
  442. * same file. The code is closely based on the default ->get_dentry() helper
  443. * fs/exportfs/expfs.c::get_object().
  444. *
  445. * The @fh contains two 32-bit unsigned values, the first one is the inode
  446. * number and the second one is the inode generation.
  447. *
  448. * Return the dentry on success or the error code on error (IS_ERR() is true).
  449. */
  450. static struct dentry *ntfs_get_dentry(struct super_block *sb, void *fh)
  451. {
  452. struct inode *vi;
  453. struct dentry *dent;
  454. unsigned long ino = ((u32 *)fh)[0];
  455. u32 gen = ((u32 *)fh)[1];
  456. ntfs_debug("Entering for inode 0x%lx, generation 0x%x.", ino, gen);
  457. vi = ntfs_iget(sb, ino);
  458. if (IS_ERR(vi)) {
  459. ntfs_error(sb, "Failed to get inode 0x%lx.", ino);
  460. return (struct dentry *)vi;
  461. }
  462. if (unlikely(is_bad_inode(vi) || vi->i_generation != gen)) {
  463. /* We didn't find the right inode. */
  464. ntfs_error(sb, "Inode 0x%lx, bad count: %d %d or version 0x%x "
  465. "0x%x.", vi->i_ino, vi->i_nlink,
  466. atomic_read(&vi->i_count), vi->i_generation,
  467. gen);
  468. iput(vi);
  469. return ERR_PTR(-ESTALE);
  470. }
  471. /* Now find a dentry. If possible, get a well-connected one. */
  472. dent = d_alloc_anon(vi);
  473. if (unlikely(!dent)) {
  474. iput(vi);
  475. return ERR_PTR(-ENOMEM);
  476. }
  477. ntfs_debug("Done for inode 0x%lx, generation 0x%x.", ino, gen);
  478. return dent;
  479. }
  480. /**
  481. * Export operations allowing NFS exporting of mounted NTFS partitions.
  482. *
  483. * We use the default ->decode_fh() and ->encode_fh() for now. Note that they
  484. * use 32 bits to store the inode number which is an unsigned long so on 64-bit
  485. * architectures is usually 64 bits so it would all fail horribly on huge
  486. * volumes. I guess we need to define our own encode and decode fh functions
  487. * that store 64-bit inode numbers at some point but for now we will ignore the
  488. * problem...
  489. *
  490. * We also use the default ->get_name() helper (used by ->decode_fh() via
  491. * fs/exportfs/expfs.c::find_exported_dentry()) as that is completely fs
  492. * independent.
  493. *
  494. * The default ->get_parent() just returns -EACCES so we have to provide our
  495. * own and the default ->get_dentry() is incompatible with NTFS due to not
  496. * allowing the inode number 0 which is used in NTFS for the system file $MFT
  497. * and due to using iget() whereas NTFS needs ntfs_iget().
  498. */
  499. struct export_operations ntfs_export_ops = {
  500. .get_parent = ntfs_get_parent, /* Find the parent of a given
  501. directory. */
  502. .get_dentry = ntfs_get_dentry, /* Find a dentry for the inode
  503. given a file handle
  504. sub-fragment. */
  505. };