2 * linux/fs/ext2/namei.c
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
11 * linux/fs/minix/namei.c
13 * Copyright (C) 1991, 1992 Linus Torvalds
15 * Big-endian to little-endian byte-swapping/bitmaps by
16 * David S. Miller (davem@caip.rutgers.edu), 1995
17 * Directory entry file type support and forward compatibility hooks
18 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
22 #include <linux/ext2_fs.h>
23 #include <linux/locks.h>
24 #include <linux/quotaops.h>
29 * define how far ahead to read directories while searching them.
31 #define NAMEI_RA_CHUNKS 2
32 #define NAMEI_RA_BLOCKS 4
33 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
34 #define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))
37 * NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
39 * `len <= EXT2_NAME_LEN' is guaranteed by caller.
40 * `de != NULL' is guaranteed by caller.
42 static inline int ext2_match (int len
, const char * const name
,
43 struct ext2_dir_entry_2
* de
)
45 if (len
!= de
->name_len
)
49 return !memcmp(name
, de
->name
, len
);
55 * finds an entry in the specified directory with the wanted name. It
56 * returns the cache buffer in which the entry was found, and the entry
57 * itself (as a parameter - res_dir). It does NOT read the inode of the
58 * entry - you'll have to do that yourself if you want to.
60 static struct buffer_head
* ext2_find_entry (struct inode
* dir
,
61 const char * const name
, int namelen
,
62 struct ext2_dir_entry_2
** res_dir
)
64 struct super_block
* sb
;
65 struct buffer_head
* bh_use
[NAMEI_RA_SIZE
];
66 struct buffer_head
* bh_read
[NAMEI_RA_SIZE
];
68 int block
, toread
, i
, err
;
73 if (namelen
> EXT2_NAME_LEN
)
76 memset (bh_use
, 0, sizeof (bh_use
));
78 for (block
= 0; block
< NAMEI_RA_SIZE
; ++block
) {
79 struct buffer_head
* bh
;
81 if ((block
<< EXT2_BLOCK_SIZE_BITS (sb
)) >= dir
->i_size
)
83 bh
= ext2_getblk (dir
, block
, 0, &err
);
85 if (bh
&& !buffer_uptodate(bh
))
86 bh_read
[toread
++] = bh
;
89 for (block
= 0, offset
= 0; offset
< dir
->i_size
; block
++) {
90 struct buffer_head
* bh
;
91 struct ext2_dir_entry_2
* de
;
94 if ((block
% NAMEI_RA_BLOCKS
) == 0 && toread
) {
95 ll_rw_block (READ
, toread
, bh_read
);
98 bh
= bh_use
[block
% NAMEI_RA_SIZE
];
101 ext2_error (sb
, "ext2_find_entry",
102 "directory #%lu contains a hole at offset %lu",
105 offset
+= sb
->s_blocksize
;
109 if (!buffer_uptodate(bh
)) {
111 * read error: all bets are off
116 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
117 dlimit
= bh
->b_data
+ sb
->s_blocksize
;
118 while ((char *) de
< dlimit
) {
119 /* this code is executed quadratically often */
120 /* do minimal checking `by hand' */
123 if ((char *) de
+ namelen
<= dlimit
&&
124 ext2_match (namelen
, name
, de
)) {
126 just to be sure, do a full check */
127 if (!ext2_check_dir_entry("ext2_find_entry",
128 dir
, de
, bh
, offset
))
130 for (i
= 0; i
< NAMEI_RA_SIZE
; ++i
) {
137 /* prevent looping on a bad block */
138 de_len
= le16_to_cpu(de
->rec_len
);
142 de
= (struct ext2_dir_entry_2
*)
143 ((char *) de
+ de_len
);
147 if (((block
+ NAMEI_RA_SIZE
) << EXT2_BLOCK_SIZE_BITS (sb
)) >=
151 bh
= ext2_getblk (dir
, block
+ NAMEI_RA_SIZE
, 0, &err
);
152 bh_use
[block
% NAMEI_RA_SIZE
] = bh
;
153 if (bh
&& !buffer_uptodate(bh
))
154 bh_read
[toread
++] = bh
;
158 for (i
= 0; i
< NAMEI_RA_SIZE
; ++i
)
163 static struct dentry
*ext2_lookup(struct inode
* dir
, struct dentry
*dentry
)
165 struct inode
* inode
;
166 struct ext2_dir_entry_2
* de
;
167 struct buffer_head
* bh
;
169 if (dentry
->d_name
.len
> EXT2_NAME_LEN
)
170 return ERR_PTR(-ENAMETOOLONG
);
172 bh
= ext2_find_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
);
175 unsigned long ino
= le32_to_cpu(de
->inode
);
177 inode
= iget(dir
->i_sb
, ino
);
180 return ERR_PTR(-EACCES
);
182 d_add(dentry
, inode
);
187 static unsigned char ext2_type_by_mode
[S_IFMT
>> S_SHIFT
] = {
188 [S_IFREG
>> S_SHIFT
] EXT2_FT_REG_FILE
,
189 [S_IFDIR
>> S_SHIFT
] EXT2_FT_DIR
,
190 [S_IFCHR
>> S_SHIFT
] EXT2_FT_CHRDEV
,
191 [S_IFBLK
>> S_SHIFT
] EXT2_FT_BLKDEV
,
192 [S_IFIFO
>> S_SHIFT
] EXT2_FT_FIFO
,
193 [S_IFSOCK
>> S_SHIFT
] EXT2_FT_SOCK
,
194 [S_IFLNK
>> S_SHIFT
] EXT2_FT_SYMLINK
,
197 static inline void ext2_set_de_type(struct super_block
*sb
,
198 struct ext2_dir_entry_2
*de
,
200 if (EXT2_HAS_INCOMPAT_FEATURE(sb
, EXT2_FEATURE_INCOMPAT_FILETYPE
))
201 de
->file_type
= ext2_type_by_mode
[(mode
& S_IFMT
)>>S_SHIFT
];
207 * adds a file entry to the specified directory.
209 int ext2_add_entry (struct inode
* dir
, const char * name
, int namelen
,
212 unsigned long offset
;
213 unsigned short rec_len
;
214 struct buffer_head
* bh
;
215 struct ext2_dir_entry_2
* de
, * de1
;
216 struct super_block
* sb
;
223 bh
= ext2_bread (dir
, 0, 0, &retval
);
226 rec_len
= EXT2_DIR_REC_LEN(namelen
);
228 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
230 if ((char *)de
>= sb
->s_blocksize
+ bh
->b_data
) {
233 bh
= ext2_bread (dir
, offset
>> EXT2_BLOCK_SIZE_BITS(sb
), 1, &retval
);
236 if (dir
->i_size
<= offset
) {
237 if (dir
->i_size
== 0) {
241 ext2_debug ("creating next block\n");
243 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
245 de
->rec_len
= le16_to_cpu(sb
->s_blocksize
);
246 dir
->i_size
= offset
+ sb
->s_blocksize
;
247 dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
248 mark_inode_dirty(dir
);
251 ext2_debug ("skipping to next block\n");
253 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
256 if (!ext2_check_dir_entry ("ext2_add_entry", dir
, de
, bh
,
261 if (ext2_match (namelen
, name
, de
)) {
265 if ((le32_to_cpu(de
->inode
) == 0 && le16_to_cpu(de
->rec_len
) >= rec_len
) ||
266 (le16_to_cpu(de
->rec_len
) >= EXT2_DIR_REC_LEN(de
->name_len
) + rec_len
)) {
267 offset
+= le16_to_cpu(de
->rec_len
);
268 if (le32_to_cpu(de
->inode
)) {
269 de1
= (struct ext2_dir_entry_2
*) ((char *) de
+
270 EXT2_DIR_REC_LEN(de
->name_len
));
271 de1
->rec_len
= cpu_to_le16(le16_to_cpu(de
->rec_len
) -
272 EXT2_DIR_REC_LEN(de
->name_len
));
273 de
->rec_len
= cpu_to_le16(EXT2_DIR_REC_LEN(de
->name_len
));
276 de
->file_type
= EXT2_FT_UNKNOWN
;
278 de
->inode
= cpu_to_le32(inode
->i_ino
);
279 ext2_set_de_type(dir
->i_sb
, de
, inode
->i_mode
);
282 de
->name_len
= namelen
;
283 memcpy (de
->name
, name
, namelen
);
285 * XXX shouldn't update any times until successful
286 * completion of syscall, but too many callers depend
289 * XXX similarly, too many callers depend on
290 * ext2_new_inode() setting the times, but error
291 * recovery deletes the inode, so the worst that can
292 * happen is that the times are slightly out of date
293 * and/or different from the directory change time.
295 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
296 dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
297 mark_inode_dirty(dir
);
298 dir
->i_version
= ++event
;
299 mark_buffer_dirty_inode(bh
, dir
);
301 ll_rw_block (WRITE
, 1, &bh
);
307 offset
+= le16_to_cpu(de
->rec_len
);
308 de
= (struct ext2_dir_entry_2
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
315 * ext2_delete_entry deletes a directory entry by merging it with the
318 static int ext2_delete_entry (struct inode
* dir
,
319 struct ext2_dir_entry_2
* de_del
,
320 struct buffer_head
* bh
)
322 struct ext2_dir_entry_2
* de
, * pde
;
327 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
328 while (i
< bh
->b_size
) {
329 if (!ext2_check_dir_entry ("ext2_delete_entry", NULL
,
335 cpu_to_le16(le16_to_cpu(pde
->rec_len
) +
336 le16_to_cpu(de
->rec_len
));
339 dir
->i_version
= ++event
;
340 mark_buffer_dirty_inode(bh
, dir
);
342 ll_rw_block (WRITE
, 1, &bh
);
347 i
+= le16_to_cpu(de
->rec_len
);
349 de
= (struct ext2_dir_entry_2
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
355 * By the time this is called, we already have created
356 * the directory cache entry for the new file, but it
357 * is so far negative - it has no inode.
359 * If the create succeeds, we fill in the inode information
360 * with d_instantiate().
362 static int ext2_create (struct inode
* dir
, struct dentry
* dentry
, int mode
)
364 struct inode
* inode
= ext2_new_inode (dir
, mode
);
365 int err
= PTR_ERR(inode
);
369 inode
->i_op
= &ext2_file_inode_operations
;
370 inode
->i_fop
= &ext2_file_operations
;
371 inode
->i_mapping
->a_ops
= &ext2_aops
;
372 inode
->i_mode
= mode
;
373 mark_inode_dirty(inode
);
374 err
= ext2_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
378 mark_inode_dirty(inode
);
382 d_instantiate(dentry
, inode
);
386 static int ext2_mknod (struct inode
* dir
, struct dentry
*dentry
, int mode
, int rdev
)
388 struct inode
* inode
= ext2_new_inode (dir
, mode
);
389 int err
= PTR_ERR(inode
);
394 inode
->i_uid
= current
->fsuid
;
395 init_special_inode(inode
, mode
, rdev
);
396 err
= ext2_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
400 mark_inode_dirty(inode
);
401 d_instantiate(dentry
, inode
);
406 mark_inode_dirty(inode
);
411 static int ext2_mkdir(struct inode
* dir
, struct dentry
* dentry
, int mode
)
413 struct inode
* inode
;
414 struct buffer_head
* dir_block
;
415 struct ext2_dir_entry_2
* de
;
418 if (dir
->i_nlink
>= EXT2_LINK_MAX
)
421 inode
= ext2_new_inode (dir
, S_IFDIR
);
422 err
= PTR_ERR(inode
);
426 inode
->i_op
= &ext2_dir_inode_operations
;
427 inode
->i_fop
= &ext2_dir_operations
;
428 inode
->i_size
= inode
->i_sb
->s_blocksize
;
430 dir_block
= ext2_bread (inode
, 0, 1, &err
);
432 inode
->i_nlink
--; /* is this nlink == 0? */
433 mark_inode_dirty(inode
);
437 de
= (struct ext2_dir_entry_2
*) dir_block
->b_data
;
438 de
->inode
= cpu_to_le32(inode
->i_ino
);
440 de
->rec_len
= cpu_to_le16(EXT2_DIR_REC_LEN(de
->name_len
));
441 strcpy (de
->name
, ".");
442 ext2_set_de_type(dir
->i_sb
, de
, S_IFDIR
);
443 de
= (struct ext2_dir_entry_2
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
444 de
->inode
= cpu_to_le32(dir
->i_ino
);
445 de
->rec_len
= cpu_to_le16(inode
->i_sb
->s_blocksize
- EXT2_DIR_REC_LEN(1));
447 strcpy (de
->name
, "..");
448 ext2_set_de_type(dir
->i_sb
, de
, S_IFDIR
);
450 mark_buffer_dirty_inode(dir_block
, dir
);
452 inode
->i_mode
= S_IFDIR
| mode
;
453 if (dir
->i_mode
& S_ISGID
)
454 inode
->i_mode
|= S_ISGID
;
455 mark_inode_dirty(inode
);
456 err
= ext2_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
461 dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
462 mark_inode_dirty(dir
);
463 d_instantiate(dentry
, inode
);
468 mark_inode_dirty(inode
);
474 * routine to check that the specified directory is empty (for rmdir)
476 static int empty_dir (struct inode
* inode
)
478 unsigned long offset
;
479 struct buffer_head
* bh
;
480 struct ext2_dir_entry_2
* de
, * de1
;
481 struct super_block
* sb
;
485 if (inode
->i_size
< EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) ||
486 !(bh
= ext2_bread (inode
, 0, 0, &err
))) {
487 ext2_warning (inode
->i_sb
, "empty_dir",
488 "bad directory (dir #%lu) - no data block",
492 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
493 de1
= (struct ext2_dir_entry_2
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
494 if (le32_to_cpu(de
->inode
) != inode
->i_ino
|| !le32_to_cpu(de1
->inode
) ||
495 strcmp (".", de
->name
) || strcmp ("..", de1
->name
)) {
496 ext2_warning (inode
->i_sb
, "empty_dir",
497 "bad directory (dir #%lu) - no `.' or `..'",
502 offset
= le16_to_cpu(de
->rec_len
) + le16_to_cpu(de1
->rec_len
);
503 de
= (struct ext2_dir_entry_2
*) ((char *) de1
+ le16_to_cpu(de1
->rec_len
));
504 while (offset
< inode
->i_size
) {
505 if (!bh
|| (void *) de
>= (void *) (bh
->b_data
+ sb
->s_blocksize
)) {
507 bh
= ext2_bread (inode
, offset
>> EXT2_BLOCK_SIZE_BITS(sb
), 0, &err
);
510 ext2_error (sb
, "empty_dir",
511 "directory #%lu contains a hole at offset %lu",
512 inode
->i_ino
, offset
);
514 offset
+= sb
->s_blocksize
;
517 de
= (struct ext2_dir_entry_2
*) bh
->b_data
;
519 if (!ext2_check_dir_entry ("empty_dir", inode
, de
, bh
,
524 if (le32_to_cpu(de
->inode
)) {
528 offset
+= le16_to_cpu(de
->rec_len
);
529 de
= (struct ext2_dir_entry_2
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
535 static int ext2_rmdir (struct inode
* dir
, struct dentry
*dentry
)
538 struct inode
* inode
;
539 struct buffer_head
* bh
;
540 struct ext2_dir_entry_2
* de
;
543 bh
= ext2_find_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
);
547 inode
= dentry
->d_inode
;
551 if (le32_to_cpu(de
->inode
) != inode
->i_ino
)
555 if (!empty_dir (inode
))
558 retval
= ext2_delete_entry(dir
, de
, bh
);
561 if (inode
->i_nlink
!= 2)
562 ext2_warning (inode
->i_sb
, "ext2_rmdir",
563 "empty directory has nlink!=2 (%d)",
565 inode
->i_version
= ++event
;
568 mark_inode_dirty(inode
);
570 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
571 dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
572 mark_inode_dirty(dir
);
579 static int ext2_unlink(struct inode
* dir
, struct dentry
*dentry
)
582 struct inode
* inode
;
583 struct buffer_head
* bh
;
584 struct ext2_dir_entry_2
* de
;
587 bh
= ext2_find_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
, &de
);
591 inode
= dentry
->d_inode
;
595 if (le32_to_cpu(de
->inode
) != inode
->i_ino
)
598 if (!inode
->i_nlink
) {
599 ext2_warning (inode
->i_sb
, "ext2_unlink",
600 "Deleting nonexistent file (%lu), %d",
601 inode
->i_ino
, inode
->i_nlink
);
604 retval
= ext2_delete_entry(dir
, de
, bh
);
607 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
608 dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
609 mark_inode_dirty(dir
);
611 mark_inode_dirty(inode
);
612 inode
->i_ctime
= dir
->i_ctime
;
620 static int ext2_symlink (struct inode
* dir
, struct dentry
*dentry
, const char * symname
)
622 struct inode
* inode
;
625 l
= strlen(symname
)+1;
626 if (l
> dir
->i_sb
->s_blocksize
)
627 return -ENAMETOOLONG
;
629 inode
= ext2_new_inode (dir
, S_IFLNK
);
630 err
= PTR_ERR(inode
);
634 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
636 if (l
> sizeof (inode
->u
.ext2_i
.i_data
)) {
637 inode
->i_op
= &page_symlink_inode_operations
;
638 inode
->i_mapping
->a_ops
= &ext2_aops
;
639 err
= block_symlink(inode
, symname
, l
);
643 inode
->i_op
= &ext2_fast_symlink_inode_operations
;
644 memcpy((char*)&inode
->u
.ext2_i
.i_data
,symname
,l
);
647 mark_inode_dirty(inode
);
649 err
= ext2_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
653 d_instantiate(dentry
, inode
);
658 mark_inode_dirty(inode
);
663 static int ext2_link (struct dentry
* old_dentry
,
664 struct inode
* dir
, struct dentry
*dentry
)
666 struct inode
*inode
= old_dentry
->d_inode
;
669 if (S_ISDIR(inode
->i_mode
))
672 if (inode
->i_nlink
>= EXT2_LINK_MAX
)
675 err
= ext2_add_entry (dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
681 inode
->i_ctime
= CURRENT_TIME
;
682 mark_inode_dirty(inode
);
683 atomic_inc(&inode
->i_count
);
684 d_instantiate(dentry
, inode
);
688 #define PARENT_INO(buffer) \
689 ((struct ext2_dir_entry_2 *) ((char *) buffer + \
690 le16_to_cpu(((struct ext2_dir_entry_2 *) buffer)->rec_len)))->inode
693 * Anybody can rename anything with this: the permission checks are left to the
694 * higher-level routines.
696 static int ext2_rename (struct inode
* old_dir
, struct dentry
*old_dentry
,
697 struct inode
* new_dir
,struct dentry
*new_dentry
)
699 struct inode
* old_inode
, * new_inode
;
700 struct buffer_head
* old_bh
, * new_bh
, * dir_bh
;
701 struct ext2_dir_entry_2
* old_de
, * new_de
;
704 old_bh
= new_bh
= dir_bh
= NULL
;
706 old_bh
= ext2_find_entry (old_dir
, old_dentry
->d_name
.name
, old_dentry
->d_name
.len
, &old_de
);
708 * Check for inode number is _not_ due to possible IO errors.
709 * We might rmdir the source, keep it as pwd of some process
710 * and merrily kill the link to whatever was created under the
711 * same name. Goodbye sticky bit ;-<
713 old_inode
= old_dentry
->d_inode
;
715 if (!old_bh
|| le32_to_cpu(old_de
->inode
) != old_inode
->i_ino
)
718 new_inode
= new_dentry
->d_inode
;
719 new_bh
= ext2_find_entry (new_dir
, new_dentry
->d_name
.name
,
720 new_dentry
->d_name
.len
, &new_de
);
726 DQUOT_INIT(new_inode
);
729 if (S_ISDIR(old_inode
->i_mode
)) {
732 if (!empty_dir (new_inode
))
736 dir_bh
= ext2_bread (old_inode
, 0, 0, &retval
);
739 if (le32_to_cpu(PARENT_INO(dir_bh
->b_data
)) != old_dir
->i_ino
)
742 if (!new_inode
&& new_dir
!=old_dir
&&
743 new_dir
->i_nlink
>= EXT2_LINK_MAX
)
747 retval
= ext2_add_entry (new_dir
, new_dentry
->d_name
.name
,
748 new_dentry
->d_name
.len
,
753 new_de
->inode
= le32_to_cpu(old_inode
->i_ino
);
754 if (EXT2_HAS_INCOMPAT_FEATURE(new_dir
->i_sb
,
755 EXT2_FEATURE_INCOMPAT_FILETYPE
))
756 new_de
->file_type
= old_de
->file_type
;
757 new_dir
->i_version
= ++event
;
758 mark_buffer_dirty_inode(new_bh
, new_dir
);
759 if (IS_SYNC(new_dir
)) {
760 ll_rw_block (WRITE
, 1, &new_bh
);
761 wait_on_buffer (new_bh
);
768 * Like most other Unix systems, set the ctime for inodes on a
771 old_inode
->i_ctime
= CURRENT_TIME
;
772 mark_inode_dirty(old_inode
);
777 ext2_delete_entry(old_dir
, old_de
, old_bh
);
780 new_inode
->i_nlink
--;
781 new_inode
->i_ctime
= CURRENT_TIME
;
782 mark_inode_dirty(new_inode
);
784 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
785 old_dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
786 mark_inode_dirty(old_dir
);
788 PARENT_INO(dir_bh
->b_data
) = le32_to_cpu(new_dir
->i_ino
);
789 mark_buffer_dirty_inode(dir_bh
, old_inode
);
791 mark_inode_dirty(old_dir
);
793 new_inode
->i_nlink
--;
794 mark_inode_dirty(new_inode
);
797 new_dir
->u
.ext2_i
.i_flags
&= ~EXT2_BTREE_FL
;
798 mark_inode_dirty(new_dir
);
812 * directories can handle most operations...
814 struct inode_operations ext2_dir_inode_operations
= {
819 symlink
: ext2_symlink
,