1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/ufs/ufs_dir.c |
4 | * |
5 | * Copyright (C) 1996 |
6 | * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu) |
7 | * Laboratory for Computer Science Research Computing Facility |
8 | * Rutgers, The State University of New Jersey |
9 | * |
10 | * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406 |
11 | * |
12 | * 4.4BSD (FreeBSD) support added on February 1st 1998 by |
13 | * Niels Kristian Bech Jensen <nkbj@image.dk> partially based |
14 | * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>. |
15 | * |
16 | * Migration to usage of "page cache" on May 2006 by |
17 | * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base. |
18 | */ |
19 | |
20 | #include <linux/time.h> |
21 | #include <linux/fs.h> |
22 | #include <linux/swap.h> |
23 | #include <linux/iversion.h> |
24 | |
25 | #include "ufs_fs.h" |
26 | #include "ufs.h" |
27 | #include "swab.h" |
28 | #include "util.h" |
29 | |
30 | /* |
31 | * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure. |
32 | * |
33 | * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller. |
34 | */ |
35 | static inline int ufs_match(struct super_block *sb, int len, |
36 | const unsigned char *name, struct ufs_dir_entry *de) |
37 | { |
38 | if (len != ufs_get_de_namlen(sb, de)) |
39 | return 0; |
40 | if (!de->d_ino) |
41 | return 0; |
42 | return !memcmp(p: name, q: de->d_name, size: len); |
43 | } |
44 | |
45 | static void ufs_commit_chunk(struct page *page, loff_t pos, unsigned len) |
46 | { |
47 | struct address_space *mapping = page->mapping; |
48 | struct inode *dir = mapping->host; |
49 | |
50 | inode_inc_iversion(inode: dir); |
51 | block_write_end(NULL, mapping, pos, len, len, page, NULL); |
52 | if (pos+len > dir->i_size) { |
53 | i_size_write(inode: dir, i_size: pos+len); |
54 | mark_inode_dirty(inode: dir); |
55 | } |
56 | unlock_page(page); |
57 | } |
58 | |
59 | static int ufs_handle_dirsync(struct inode *dir) |
60 | { |
61 | int err; |
62 | |
63 | err = filemap_write_and_wait(mapping: dir->i_mapping); |
64 | if (!err) |
65 | err = sync_inode_metadata(inode: dir, wait: 1); |
66 | return err; |
67 | } |
68 | |
69 | static inline void ufs_put_page(struct page *page) |
70 | { |
71 | kunmap(page); |
72 | put_page(page); |
73 | } |
74 | |
75 | ino_t ufs_inode_by_name(struct inode *dir, const struct qstr *qstr) |
76 | { |
77 | ino_t res = 0; |
78 | struct ufs_dir_entry *de; |
79 | struct page *page; |
80 | |
81 | de = ufs_find_entry(dir, qstr, &page); |
82 | if (de) { |
83 | res = fs32_to_cpu(sbp: dir->i_sb, n: de->d_ino); |
84 | ufs_put_page(page); |
85 | } |
86 | return res; |
87 | } |
88 | |
89 | |
90 | /* Releases the page */ |
91 | void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de, |
92 | struct page *page, struct inode *inode, |
93 | bool update_times) |
94 | { |
95 | loff_t pos = page_offset(page) + |
96 | (char *) de - (char *) page_address(page); |
97 | unsigned len = fs16_to_cpu(sbp: dir->i_sb, n: de->d_reclen); |
98 | int err; |
99 | |
100 | lock_page(page); |
101 | err = ufs_prepare_chunk(page, pos, len); |
102 | BUG_ON(err); |
103 | |
104 | de->d_ino = cpu_to_fs32(sbp: dir->i_sb, n: inode->i_ino); |
105 | ufs_set_de_type(sb: dir->i_sb, de, mode: inode->i_mode); |
106 | |
107 | ufs_commit_chunk(page, pos, len); |
108 | ufs_put_page(page); |
109 | if (update_times) |
110 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
111 | mark_inode_dirty(inode: dir); |
112 | ufs_handle_dirsync(dir); |
113 | } |
114 | |
115 | |
116 | static bool ufs_check_page(struct page *page) |
117 | { |
118 | struct inode *dir = page->mapping->host; |
119 | struct super_block *sb = dir->i_sb; |
120 | char *kaddr = page_address(page); |
121 | unsigned offs, rec_len; |
122 | unsigned limit = PAGE_SIZE; |
123 | const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1; |
124 | struct ufs_dir_entry *p; |
125 | char *error; |
126 | |
127 | if ((dir->i_size >> PAGE_SHIFT) == page->index) { |
128 | limit = dir->i_size & ~PAGE_MASK; |
129 | if (limit & chunk_mask) |
130 | goto Ebadsize; |
131 | if (!limit) |
132 | goto out; |
133 | } |
134 | for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) { |
135 | p = (struct ufs_dir_entry *)(kaddr + offs); |
136 | rec_len = fs16_to_cpu(sbp: sb, n: p->d_reclen); |
137 | |
138 | if (rec_len < UFS_DIR_REC_LEN(1)) |
139 | goto Eshort; |
140 | if (rec_len & 3) |
141 | goto Ealign; |
142 | if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p))) |
143 | goto Enamelen; |
144 | if (((offs + rec_len - 1) ^ offs) & ~chunk_mask) |
145 | goto Espan; |
146 | if (fs32_to_cpu(sbp: sb, n: p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg * |
147 | UFS_SB(sb)->s_uspi->s_ncg)) |
148 | goto Einumber; |
149 | } |
150 | if (offs != limit) |
151 | goto Eend; |
152 | out: |
153 | SetPageChecked(page); |
154 | return true; |
155 | |
156 | /* Too bad, we had an error */ |
157 | |
158 | Ebadsize: |
159 | ufs_error(sb, "ufs_check_page" , |
160 | "size of directory #%lu is not a multiple of chunk size" , |
161 | dir->i_ino |
162 | ); |
163 | goto fail; |
164 | Eshort: |
165 | error = "rec_len is smaller than minimal" ; |
166 | goto bad_entry; |
167 | Ealign: |
168 | error = "unaligned directory entry" ; |
169 | goto bad_entry; |
170 | Enamelen: |
171 | error = "rec_len is too small for name_len" ; |
172 | goto bad_entry; |
173 | Espan: |
174 | error = "directory entry across blocks" ; |
175 | goto bad_entry; |
176 | Einumber: |
177 | error = "inode out of bounds" ; |
178 | bad_entry: |
179 | ufs_error (sb, "ufs_check_page" , "bad entry in directory #%lu: %s - " |
180 | "offset=%lu, rec_len=%d, name_len=%d" , |
181 | dir->i_ino, error, (page->index<<PAGE_SHIFT)+offs, |
182 | rec_len, ufs_get_de_namlen(sb, de: p)); |
183 | goto fail; |
184 | Eend: |
185 | p = (struct ufs_dir_entry *)(kaddr + offs); |
186 | ufs_error(sb, __func__, |
187 | "entry in directory #%lu spans the page boundary" |
188 | "offset=%lu" , |
189 | dir->i_ino, (page->index<<PAGE_SHIFT)+offs); |
190 | fail: |
191 | SetPageError(page); |
192 | return false; |
193 | } |
194 | |
195 | static struct page *ufs_get_page(struct inode *dir, unsigned long n) |
196 | { |
197 | struct address_space *mapping = dir->i_mapping; |
198 | struct page *page = read_mapping_page(mapping, index: n, NULL); |
199 | if (!IS_ERR(ptr: page)) { |
200 | kmap(page); |
201 | if (unlikely(!PageChecked(page))) { |
202 | if (!ufs_check_page(page)) |
203 | goto fail; |
204 | } |
205 | } |
206 | return page; |
207 | |
208 | fail: |
209 | ufs_put_page(page); |
210 | return ERR_PTR(error: -EIO); |
211 | } |
212 | |
213 | /* |
214 | * Return the offset into page `page_nr' of the last valid |
215 | * byte in that page, plus one. |
216 | */ |
217 | static unsigned |
218 | ufs_last_byte(struct inode *inode, unsigned long page_nr) |
219 | { |
220 | unsigned last_byte = inode->i_size; |
221 | |
222 | last_byte -= page_nr << PAGE_SHIFT; |
223 | if (last_byte > PAGE_SIZE) |
224 | last_byte = PAGE_SIZE; |
225 | return last_byte; |
226 | } |
227 | |
228 | static inline struct ufs_dir_entry * |
229 | ufs_next_entry(struct super_block *sb, struct ufs_dir_entry *p) |
230 | { |
231 | return (struct ufs_dir_entry *)((char *)p + |
232 | fs16_to_cpu(sbp: sb, n: p->d_reclen)); |
233 | } |
234 | |
235 | struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p) |
236 | { |
237 | struct page *page = ufs_get_page(dir, n: 0); |
238 | struct ufs_dir_entry *de = NULL; |
239 | |
240 | if (!IS_ERR(ptr: page)) { |
241 | de = ufs_next_entry(sb: dir->i_sb, |
242 | p: (struct ufs_dir_entry *)page_address(page)); |
243 | *p = page; |
244 | } |
245 | return de; |
246 | } |
247 | |
248 | /* |
249 | * ufs_find_entry() |
250 | * |
251 | * finds an entry in the specified directory with the wanted name. It |
252 | * returns the page in which the entry was found, and the entry itself |
253 | * (as a parameter - res_dir). Page is returned mapped and unlocked. |
254 | * Entry is guaranteed to be valid. |
255 | */ |
256 | struct ufs_dir_entry *ufs_find_entry(struct inode *dir, const struct qstr *qstr, |
257 | struct page **res_page) |
258 | { |
259 | struct super_block *sb = dir->i_sb; |
260 | const unsigned char *name = qstr->name; |
261 | int namelen = qstr->len; |
262 | unsigned reclen = UFS_DIR_REC_LEN(namelen); |
263 | unsigned long start, n; |
264 | unsigned long npages = dir_pages(inode: dir); |
265 | struct page *page = NULL; |
266 | struct ufs_inode_info *ui = UFS_I(inode: dir); |
267 | struct ufs_dir_entry *de; |
268 | |
269 | UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n" , dir->i_ino, name, namelen); |
270 | |
271 | if (npages == 0 || namelen > UFS_MAXNAMLEN) |
272 | goto out; |
273 | |
274 | /* OFFSET_CACHE */ |
275 | *res_page = NULL; |
276 | |
277 | start = ui->i_dir_start_lookup; |
278 | |
279 | if (start >= npages) |
280 | start = 0; |
281 | n = start; |
282 | do { |
283 | char *kaddr; |
284 | page = ufs_get_page(dir, n); |
285 | if (!IS_ERR(ptr: page)) { |
286 | kaddr = page_address(page); |
287 | de = (struct ufs_dir_entry *) kaddr; |
288 | kaddr += ufs_last_byte(inode: dir, page_nr: n) - reclen; |
289 | while ((char *) de <= kaddr) { |
290 | if (ufs_match(sb, len: namelen, name, de)) |
291 | goto found; |
292 | de = ufs_next_entry(sb, p: de); |
293 | } |
294 | ufs_put_page(page); |
295 | } |
296 | if (++n >= npages) |
297 | n = 0; |
298 | } while (n != start); |
299 | out: |
300 | return NULL; |
301 | |
302 | found: |
303 | *res_page = page; |
304 | ui->i_dir_start_lookup = n; |
305 | return de; |
306 | } |
307 | |
308 | /* |
309 | * Parent is locked. |
310 | */ |
311 | int ufs_add_link(struct dentry *dentry, struct inode *inode) |
312 | { |
313 | struct inode *dir = d_inode(dentry: dentry->d_parent); |
314 | const unsigned char *name = dentry->d_name.name; |
315 | int namelen = dentry->d_name.len; |
316 | struct super_block *sb = dir->i_sb; |
317 | unsigned reclen = UFS_DIR_REC_LEN(namelen); |
318 | const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize; |
319 | unsigned short rec_len, name_len; |
320 | struct page *page = NULL; |
321 | struct ufs_dir_entry *de; |
322 | unsigned long npages = dir_pages(inode: dir); |
323 | unsigned long n; |
324 | char *kaddr; |
325 | loff_t pos; |
326 | int err; |
327 | |
328 | UFSD("ENTER, name %s, namelen %u\n" , name, namelen); |
329 | |
330 | /* |
331 | * We take care of directory expansion in the same loop. |
332 | * This code plays outside i_size, so it locks the page |
333 | * to protect that region. |
334 | */ |
335 | for (n = 0; n <= npages; n++) { |
336 | char *dir_end; |
337 | |
338 | page = ufs_get_page(dir, n); |
339 | err = PTR_ERR(ptr: page); |
340 | if (IS_ERR(ptr: page)) |
341 | goto out; |
342 | lock_page(page); |
343 | kaddr = page_address(page); |
344 | dir_end = kaddr + ufs_last_byte(inode: dir, page_nr: n); |
345 | de = (struct ufs_dir_entry *)kaddr; |
346 | kaddr += PAGE_SIZE - reclen; |
347 | while ((char *)de <= kaddr) { |
348 | if ((char *)de == dir_end) { |
349 | /* We hit i_size */ |
350 | name_len = 0; |
351 | rec_len = chunk_size; |
352 | de->d_reclen = cpu_to_fs16(sbp: sb, n: chunk_size); |
353 | de->d_ino = 0; |
354 | goto got_it; |
355 | } |
356 | if (de->d_reclen == 0) { |
357 | ufs_error(dir->i_sb, __func__, |
358 | "zero-length directory entry" ); |
359 | err = -EIO; |
360 | goto out_unlock; |
361 | } |
362 | err = -EEXIST; |
363 | if (ufs_match(sb, len: namelen, name, de)) |
364 | goto out_unlock; |
365 | name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)); |
366 | rec_len = fs16_to_cpu(sbp: sb, n: de->d_reclen); |
367 | if (!de->d_ino && rec_len >= reclen) |
368 | goto got_it; |
369 | if (rec_len >= name_len + reclen) |
370 | goto got_it; |
371 | de = (struct ufs_dir_entry *) ((char *) de + rec_len); |
372 | } |
373 | unlock_page(page); |
374 | ufs_put_page(page); |
375 | } |
376 | BUG(); |
377 | return -EINVAL; |
378 | |
379 | got_it: |
380 | pos = page_offset(page) + |
381 | (char*)de - (char*)page_address(page); |
382 | err = ufs_prepare_chunk(page, pos, len: rec_len); |
383 | if (err) |
384 | goto out_unlock; |
385 | if (de->d_ino) { |
386 | struct ufs_dir_entry *de1 = |
387 | (struct ufs_dir_entry *) ((char *) de + name_len); |
388 | de1->d_reclen = cpu_to_fs16(sbp: sb, n: rec_len - name_len); |
389 | de->d_reclen = cpu_to_fs16(sbp: sb, n: name_len); |
390 | |
391 | de = de1; |
392 | } |
393 | |
394 | ufs_set_de_namlen(sb, de, value: namelen); |
395 | memcpy(de->d_name, name, namelen + 1); |
396 | de->d_ino = cpu_to_fs32(sbp: sb, n: inode->i_ino); |
397 | ufs_set_de_type(sb, de, mode: inode->i_mode); |
398 | |
399 | ufs_commit_chunk(page, pos, len: rec_len); |
400 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
401 | |
402 | mark_inode_dirty(inode: dir); |
403 | err = ufs_handle_dirsync(dir); |
404 | /* OFFSET_CACHE */ |
405 | out_put: |
406 | ufs_put_page(page); |
407 | out: |
408 | return err; |
409 | out_unlock: |
410 | unlock_page(page); |
411 | goto out_put; |
412 | } |
413 | |
414 | static inline unsigned |
415 | ufs_validate_entry(struct super_block *sb, char *base, |
416 | unsigned offset, unsigned mask) |
417 | { |
418 | struct ufs_dir_entry *de = (struct ufs_dir_entry*)(base + offset); |
419 | struct ufs_dir_entry *p = (struct ufs_dir_entry*)(base + (offset&mask)); |
420 | while ((char*)p < (char*)de) |
421 | p = ufs_next_entry(sb, p); |
422 | return (char *)p - base; |
423 | } |
424 | |
425 | |
426 | /* |
427 | * This is blatantly stolen from ext2fs |
428 | */ |
429 | static int |
430 | ufs_readdir(struct file *file, struct dir_context *ctx) |
431 | { |
432 | loff_t pos = ctx->pos; |
433 | struct inode *inode = file_inode(f: file); |
434 | struct super_block *sb = inode->i_sb; |
435 | unsigned int offset = pos & ~PAGE_MASK; |
436 | unsigned long n = pos >> PAGE_SHIFT; |
437 | unsigned long npages = dir_pages(inode); |
438 | unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1); |
439 | bool need_revalidate = !inode_eq_iversion(inode, old: file->f_version); |
440 | unsigned flags = UFS_SB(sb)->s_flags; |
441 | |
442 | UFSD("BEGIN\n" ); |
443 | |
444 | if (pos > inode->i_size - UFS_DIR_REC_LEN(1)) |
445 | return 0; |
446 | |
447 | for ( ; n < npages; n++, offset = 0) { |
448 | char *kaddr, *limit; |
449 | struct ufs_dir_entry *de; |
450 | |
451 | struct page *page = ufs_get_page(dir: inode, n); |
452 | |
453 | if (IS_ERR(ptr: page)) { |
454 | ufs_error(sb, __func__, |
455 | "bad page in #%lu" , |
456 | inode->i_ino); |
457 | ctx->pos += PAGE_SIZE - offset; |
458 | return -EIO; |
459 | } |
460 | kaddr = page_address(page); |
461 | if (unlikely(need_revalidate)) { |
462 | if (offset) { |
463 | offset = ufs_validate_entry(sb, base: kaddr, offset, mask: chunk_mask); |
464 | ctx->pos = (n<<PAGE_SHIFT) + offset; |
465 | } |
466 | file->f_version = inode_query_iversion(inode); |
467 | need_revalidate = false; |
468 | } |
469 | de = (struct ufs_dir_entry *)(kaddr+offset); |
470 | limit = kaddr + ufs_last_byte(inode, page_nr: n) - UFS_DIR_REC_LEN(1); |
471 | for ( ;(char*)de <= limit; de = ufs_next_entry(sb, p: de)) { |
472 | if (de->d_ino) { |
473 | unsigned char d_type = DT_UNKNOWN; |
474 | |
475 | UFSD("filldir(%s,%u)\n" , de->d_name, |
476 | fs32_to_cpu(sb, de->d_ino)); |
477 | UFSD("namlen %u\n" , ufs_get_de_namlen(sb, de)); |
478 | |
479 | if ((flags & UFS_DE_MASK) == UFS_DE_44BSD) |
480 | d_type = de->d_u.d_44.d_type; |
481 | |
482 | if (!dir_emit(ctx, name: de->d_name, |
483 | namelen: ufs_get_de_namlen(sb, de), |
484 | ino: fs32_to_cpu(sbp: sb, n: de->d_ino), |
485 | type: d_type)) { |
486 | ufs_put_page(page); |
487 | return 0; |
488 | } |
489 | } |
490 | ctx->pos += fs16_to_cpu(sbp: sb, n: de->d_reclen); |
491 | } |
492 | ufs_put_page(page); |
493 | } |
494 | return 0; |
495 | } |
496 | |
497 | |
498 | /* |
499 | * ufs_delete_entry deletes a directory entry by merging it with the |
500 | * previous entry. |
501 | */ |
502 | int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir, |
503 | struct page * page) |
504 | { |
505 | struct super_block *sb = inode->i_sb; |
506 | char *kaddr = page_address(page); |
507 | unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1); |
508 | unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sbp: sb, n: dir->d_reclen); |
509 | loff_t pos; |
510 | struct ufs_dir_entry *pde = NULL; |
511 | struct ufs_dir_entry *de = (struct ufs_dir_entry *) (kaddr + from); |
512 | int err; |
513 | |
514 | UFSD("ENTER\n" ); |
515 | |
516 | UFSD("ino %u, reclen %u, namlen %u, name %s\n" , |
517 | fs32_to_cpu(sb, de->d_ino), |
518 | fs16_to_cpu(sb, de->d_reclen), |
519 | ufs_get_de_namlen(sb, de), de->d_name); |
520 | |
521 | while ((char*)de < (char*)dir) { |
522 | if (de->d_reclen == 0) { |
523 | ufs_error(inode->i_sb, __func__, |
524 | "zero-length directory entry" ); |
525 | err = -EIO; |
526 | goto out; |
527 | } |
528 | pde = de; |
529 | de = ufs_next_entry(sb, p: de); |
530 | } |
531 | if (pde) |
532 | from = (char*)pde - (char*)page_address(page); |
533 | |
534 | pos = page_offset(page) + from; |
535 | lock_page(page); |
536 | err = ufs_prepare_chunk(page, pos, len: to - from); |
537 | BUG_ON(err); |
538 | if (pde) |
539 | pde->d_reclen = cpu_to_fs16(sbp: sb, n: to - from); |
540 | dir->d_ino = 0; |
541 | ufs_commit_chunk(page, pos, len: to - from); |
542 | inode_set_mtime_to_ts(inode, ts: inode_set_ctime_current(inode)); |
543 | mark_inode_dirty(inode); |
544 | err = ufs_handle_dirsync(dir: inode); |
545 | out: |
546 | ufs_put_page(page); |
547 | UFSD("EXIT\n" ); |
548 | return err; |
549 | } |
550 | |
551 | int ufs_make_empty(struct inode * inode, struct inode *dir) |
552 | { |
553 | struct super_block * sb = dir->i_sb; |
554 | struct address_space *mapping = inode->i_mapping; |
555 | struct page *page = grab_cache_page(mapping, index: 0); |
556 | const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize; |
557 | struct ufs_dir_entry * de; |
558 | char *base; |
559 | int err; |
560 | |
561 | if (!page) |
562 | return -ENOMEM; |
563 | |
564 | err = ufs_prepare_chunk(page, pos: 0, len: chunk_size); |
565 | if (err) { |
566 | unlock_page(page); |
567 | goto fail; |
568 | } |
569 | |
570 | kmap(page); |
571 | base = (char*)page_address(page); |
572 | memset(base, 0, PAGE_SIZE); |
573 | |
574 | de = (struct ufs_dir_entry *) base; |
575 | |
576 | de->d_ino = cpu_to_fs32(sbp: sb, n: inode->i_ino); |
577 | ufs_set_de_type(sb, de, mode: inode->i_mode); |
578 | ufs_set_de_namlen(sb, de, value: 1); |
579 | de->d_reclen = cpu_to_fs16(sbp: sb, UFS_DIR_REC_LEN(1)); |
580 | strcpy (p: de->d_name, q: "." ); |
581 | de = (struct ufs_dir_entry *) |
582 | ((char *)de + fs16_to_cpu(sbp: sb, n: de->d_reclen)); |
583 | de->d_ino = cpu_to_fs32(sbp: sb, n: dir->i_ino); |
584 | ufs_set_de_type(sb, de, mode: dir->i_mode); |
585 | de->d_reclen = cpu_to_fs16(sbp: sb, n: chunk_size - UFS_DIR_REC_LEN(1)); |
586 | ufs_set_de_namlen(sb, de, value: 2); |
587 | strcpy (p: de->d_name, q: ".." ); |
588 | kunmap(page); |
589 | |
590 | ufs_commit_chunk(page, pos: 0, len: chunk_size); |
591 | err = ufs_handle_dirsync(dir: inode); |
592 | fail: |
593 | put_page(page); |
594 | return err; |
595 | } |
596 | |
597 | /* |
598 | * routine to check that the specified directory is empty (for rmdir) |
599 | */ |
600 | int ufs_empty_dir(struct inode * inode) |
601 | { |
602 | struct super_block *sb = inode->i_sb; |
603 | struct page *page = NULL; |
604 | unsigned long i, npages = dir_pages(inode); |
605 | |
606 | for (i = 0; i < npages; i++) { |
607 | char *kaddr; |
608 | struct ufs_dir_entry *de; |
609 | page = ufs_get_page(dir: inode, n: i); |
610 | |
611 | if (IS_ERR(ptr: page)) |
612 | continue; |
613 | |
614 | kaddr = page_address(page); |
615 | de = (struct ufs_dir_entry *)kaddr; |
616 | kaddr += ufs_last_byte(inode, page_nr: i) - UFS_DIR_REC_LEN(1); |
617 | |
618 | while ((char *)de <= kaddr) { |
619 | if (de->d_reclen == 0) { |
620 | ufs_error(inode->i_sb, __func__, |
621 | "zero-length directory entry: " |
622 | "kaddr=%p, de=%p\n" , kaddr, de); |
623 | goto not_empty; |
624 | } |
625 | if (de->d_ino) { |
626 | u16 namelen=ufs_get_de_namlen(sb, de); |
627 | /* check for . and .. */ |
628 | if (de->d_name[0] != '.') |
629 | goto not_empty; |
630 | if (namelen > 2) |
631 | goto not_empty; |
632 | if (namelen < 2) { |
633 | if (inode->i_ino != |
634 | fs32_to_cpu(sbp: sb, n: de->d_ino)) |
635 | goto not_empty; |
636 | } else if (de->d_name[1] != '.') |
637 | goto not_empty; |
638 | } |
639 | de = ufs_next_entry(sb, p: de); |
640 | } |
641 | ufs_put_page(page); |
642 | } |
643 | return 1; |
644 | |
645 | not_empty: |
646 | ufs_put_page(page); |
647 | return 0; |
648 | } |
649 | |
650 | const struct file_operations ufs_dir_operations = { |
651 | .read = generic_read_dir, |
652 | .iterate_shared = ufs_readdir, |
653 | .fsync = generic_file_fsync, |
654 | .llseek = generic_file_llseek, |
655 | }; |
656 | |