Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/fs/sysv/dir.c | |
4 | * | |
5 | * minix/dir.c | |
6 | * Copyright (C) 1991, 1992 Linus Torvalds | |
7 | * | |
8 | * coh/dir.c | |
9 | * Copyright (C) 1993 Pascal Haible, Bruno Haible | |
10 | * | |
11 | * sysv/dir.c | |
12 | * Copyright (C) 1993 Bruno Haible | |
13 | * | |
14 | * SystemV/Coherent directory handling functions | |
15 | */ | |
16 | ||
17 | #include <linux/pagemap.h> | |
18 | #include <linux/highmem.h> | |
26a6441a | 19 | #include <linux/swap.h> |
1da177e4 LT |
20 | #include "sysv.h" |
21 | ||
80886298 | 22 | static int sysv_readdir(struct file *, struct dir_context *); |
1da177e4 | 23 | |
4b6f5d20 | 24 | const struct file_operations sysv_dir_operations = { |
5ac3455a | 25 | .llseek = generic_file_llseek, |
1da177e4 | 26 | .read = generic_read_dir, |
3b0a3c1a | 27 | .iterate_shared = sysv_readdir, |
1b061d92 | 28 | .fsync = generic_file_fsync, |
1da177e4 LT |
29 | }; |
30 | ||
4309093e | 31 | static void dir_commit_chunk(struct page *page, loff_t pos, unsigned len) |
1da177e4 | 32 | { |
26a6441a NP |
33 | struct address_space *mapping = page->mapping; |
34 | struct inode *dir = mapping->host; | |
1da177e4 | 35 | |
26a6441a NP |
36 | block_write_end(NULL, mapping, pos, len, len, page, NULL); |
37 | if (pos+len > dir->i_size) { | |
38 | i_size_write(dir, pos+len); | |
39 | mark_inode_dirty(dir); | |
40 | } | |
4309093e CH |
41 | unlock_page(page); |
42 | } | |
43 | ||
44 | static int sysv_handle_dirsync(struct inode *dir) | |
45 | { | |
46 | int err; | |
47 | ||
48 | err = filemap_write_and_wait(dir->i_mapping); | |
49 | if (!err) | |
50 | err = sync_inode_metadata(dir, 1); | |
1da177e4 LT |
51 | return err; |
52 | } | |
53 | ||
83005276 | 54 | /* |
ede3ef5c | 55 | * Calls to dir_get_page()/put_and_unmap_page() must be nested according to the |
83005276 FDF |
56 | * rules documented in mm/highmem.rst. |
57 | * | |
58 | * NOTE: sysv_find_entry() and sysv_dotdot() act as calls to dir_get_page() | |
59 | * and must be treated accordingly for nesting purposes. | |
60 | */ | |
8dd6c7b2 | 61 | static void *dir_get_page(struct inode *dir, unsigned long n, struct page **p) |
1da177e4 LT |
62 | { |
63 | struct address_space *mapping = dir->i_mapping; | |
090d2b18 | 64 | struct page *page = read_mapping_page(mapping, n, NULL); |
8dd6c7b2 FDF |
65 | if (IS_ERR(page)) |
66 | return ERR_CAST(page); | |
8dd6c7b2 | 67 | *p = page; |
83005276 | 68 | return kmap_local_page(page); |
1da177e4 LT |
69 | } |
70 | ||
80886298 | 71 | static int sysv_readdir(struct file *file, struct dir_context *ctx) |
1da177e4 | 72 | { |
80886298 AV |
73 | unsigned long pos = ctx->pos; |
74 | struct inode *inode = file_inode(file); | |
1da177e4 | 75 | struct super_block *sb = inode->i_sb; |
1da177e4 | 76 | unsigned long npages = dir_pages(inode); |
80886298 AV |
77 | unsigned offset; |
78 | unsigned long n; | |
1da177e4 | 79 | |
80886298 | 80 | ctx->pos = pos = (pos + SYSV_DIRSIZE-1) & ~(SYSV_DIRSIZE-1); |
1da177e4 | 81 | if (pos >= inode->i_size) |
80886298 AV |
82 | return 0; |
83 | ||
09cbfeaf KS |
84 | offset = pos & ~PAGE_MASK; |
85 | n = pos >> PAGE_SHIFT; | |
1da177e4 LT |
86 | |
87 | for ( ; n < npages; n++, offset = 0) { | |
88 | char *kaddr, *limit; | |
89 | struct sysv_dir_entry *de; | |
8dd6c7b2 | 90 | struct page *page; |
1da177e4 | 91 | |
8dd6c7b2 FDF |
92 | kaddr = dir_get_page(inode, n, &page); |
93 | if (IS_ERR(kaddr)) | |
1da177e4 | 94 | continue; |
1da177e4 | 95 | de = (struct sysv_dir_entry *)(kaddr+offset); |
09cbfeaf | 96 | limit = kaddr + PAGE_SIZE - SYSV_DIRSIZE; |
80886298 | 97 | for ( ;(char*)de <= limit; de++, ctx->pos += sizeof(*de)) { |
1da177e4 | 98 | char *name = de->name; |
1da177e4 LT |
99 | |
100 | if (!de->inode) | |
101 | continue; | |
102 | ||
80886298 | 103 | if (!dir_emit(ctx, name, strnlen(name,SYSV_NAMELEN), |
1da177e4 | 104 | fs16_to_cpu(SYSV_SB(sb), de->inode), |
80886298 | 105 | DT_UNKNOWN)) { |
ede3ef5c | 106 | put_and_unmap_page(page, kaddr); |
80886298 | 107 | return 0; |
1da177e4 LT |
108 | } |
109 | } | |
ede3ef5c | 110 | put_and_unmap_page(page, kaddr); |
1da177e4 | 111 | } |
1da177e4 LT |
112 | return 0; |
113 | } | |
114 | ||
115 | /* compare strings: name[0..len-1] (not zero-terminated) and | |
116 | * buffer[0..] (filled with zeroes up to buffer[0..maxlen-1]) | |
117 | */ | |
118 | static inline int namecompare(int len, int maxlen, | |
119 | const char * name, const char * buffer) | |
120 | { | |
121 | if (len < maxlen && buffer[len]) | |
122 | return 0; | |
123 | return !memcmp(name, buffer, len); | |
124 | } | |
125 | ||
126 | /* | |
127 | * sysv_find_entry() | |
128 | * | |
129 | * finds an entry in the specified directory with the wanted name. It | |
130 | * returns the cache buffer in which the entry was found, and the entry | |
131 | * itself (as a parameter - res_dir). It does NOT read the inode of the | |
132 | * entry - you'll have to do that yourself if you want to. | |
83005276 | 133 | * |
ede3ef5c | 134 | * On Success put_and_unmap_page() should be called on *res_page. |
83005276 FDF |
135 | * |
136 | * sysv_find_entry() acts as a call to dir_get_page() and must be treated | |
137 | * accordingly for nesting purposes. | |
1da177e4 LT |
138 | */ |
139 | struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_page) | |
140 | { | |
141 | const char * name = dentry->d_name.name; | |
142 | int namelen = dentry->d_name.len; | |
2b0143b5 | 143 | struct inode * dir = d_inode(dentry->d_parent); |
1da177e4 LT |
144 | unsigned long start, n; |
145 | unsigned long npages = dir_pages(dir); | |
146 | struct page *page = NULL; | |
147 | struct sysv_dir_entry *de; | |
148 | ||
149 | *res_page = NULL; | |
150 | ||
151 | start = SYSV_I(dir)->i_dir_start_lookup; | |
152 | if (start >= npages) | |
153 | start = 0; | |
154 | n = start; | |
155 | ||
156 | do { | |
8dd6c7b2 FDF |
157 | char *kaddr = dir_get_page(dir, n, &page); |
158 | ||
159 | if (!IS_ERR(kaddr)) { | |
160 | de = (struct sysv_dir_entry *)kaddr; | |
09cbfeaf | 161 | kaddr += PAGE_SIZE - SYSV_DIRSIZE; |
1da177e4 LT |
162 | for ( ; (char *) de <= kaddr ; de++) { |
163 | if (!de->inode) | |
164 | continue; | |
165 | if (namecompare(namelen, SYSV_NAMELEN, | |
166 | name, de->name)) | |
167 | goto found; | |
168 | } | |
ede3ef5c | 169 | put_and_unmap_page(page, kaddr); |
1da177e4 | 170 | } |
1da177e4 LT |
171 | |
172 | if (++n >= npages) | |
173 | n = 0; | |
174 | } while (n != start); | |
175 | ||
176 | return NULL; | |
177 | ||
178 | found: | |
179 | SYSV_I(dir)->i_dir_start_lookup = n; | |
180 | *res_page = page; | |
181 | return de; | |
182 | } | |
183 | ||
184 | int sysv_add_link(struct dentry *dentry, struct inode *inode) | |
185 | { | |
2b0143b5 | 186 | struct inode *dir = d_inode(dentry->d_parent); |
1da177e4 LT |
187 | const char * name = dentry->d_name.name; |
188 | int namelen = dentry->d_name.len; | |
189 | struct page *page = NULL; | |
190 | struct sysv_dir_entry * de; | |
191 | unsigned long npages = dir_pages(dir); | |
192 | unsigned long n; | |
193 | char *kaddr; | |
26a6441a | 194 | loff_t pos; |
1da177e4 LT |
195 | int err; |
196 | ||
197 | /* We take care of directory expansion in the same loop */ | |
198 | for (n = 0; n <= npages; n++) { | |
8dd6c7b2 FDF |
199 | kaddr = dir_get_page(dir, n, &page); |
200 | if (IS_ERR(kaddr)) | |
201 | return PTR_ERR(kaddr); | |
1da177e4 | 202 | de = (struct sysv_dir_entry *)kaddr; |
09cbfeaf | 203 | kaddr += PAGE_SIZE - SYSV_DIRSIZE; |
1da177e4 LT |
204 | while ((char *)de <= kaddr) { |
205 | if (!de->inode) | |
206 | goto got_it; | |
207 | err = -EEXIST; | |
208 | if (namecompare(namelen, SYSV_NAMELEN, name, de->name)) | |
209 | goto out_page; | |
210 | de++; | |
211 | } | |
ede3ef5c | 212 | put_and_unmap_page(page, kaddr); |
1da177e4 LT |
213 | } |
214 | BUG(); | |
215 | return -EINVAL; | |
216 | ||
217 | got_it: | |
4bb1a137 | 218 | pos = page_offset(page) + offset_in_page(de); |
1da177e4 | 219 | lock_page(page); |
f4e420dc | 220 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 LT |
221 | if (err) |
222 | goto out_unlock; | |
223 | memcpy (de->name, name, namelen); | |
224 | memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2); | |
225 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); | |
4309093e | 226 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
02027d42 | 227 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 | 228 | mark_inode_dirty(dir); |
4309093e | 229 | err = sysv_handle_dirsync(dir); |
1da177e4 | 230 | out_page: |
ede3ef5c | 231 | put_and_unmap_page(page, kaddr); |
1da177e4 LT |
232 | return err; |
233 | out_unlock: | |
234 | unlock_page(page); | |
235 | goto out_page; | |
236 | } | |
237 | ||
238 | int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page) | |
239 | { | |
f4e420dc | 240 | struct inode *inode = page->mapping->host; |
4bb1a137 | 241 | loff_t pos = page_offset(page) + offset_in_page(de); |
1da177e4 LT |
242 | int err; |
243 | ||
244 | lock_page(page); | |
f4e420dc | 245 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
abb7c742 AV |
246 | if (err) { |
247 | unlock_page(page); | |
248 | return err; | |
249 | } | |
1da177e4 | 250 | de->inode = 0; |
4309093e | 251 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
02027d42 | 252 | inode->i_ctime = inode->i_mtime = current_time(inode); |
1da177e4 | 253 | mark_inode_dirty(inode); |
4309093e | 254 | return sysv_handle_dirsync(inode); |
1da177e4 LT |
255 | } |
256 | ||
257 | int sysv_make_empty(struct inode *inode, struct inode *dir) | |
258 | { | |
f4e420dc | 259 | struct page *page = grab_cache_page(inode->i_mapping, 0); |
1da177e4 LT |
260 | struct sysv_dir_entry * de; |
261 | char *base; | |
262 | int err; | |
263 | ||
264 | if (!page) | |
265 | return -ENOMEM; | |
f4e420dc | 266 | err = sysv_prepare_chunk(page, 0, 2 * SYSV_DIRSIZE); |
1da177e4 LT |
267 | if (err) { |
268 | unlock_page(page); | |
269 | goto fail; | |
270 | } | |
83005276 | 271 | base = kmap_local_page(page); |
09cbfeaf | 272 | memset(base, 0, PAGE_SIZE); |
1da177e4 LT |
273 | |
274 | de = (struct sysv_dir_entry *) base; | |
275 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); | |
276 | strcpy(de->name,"."); | |
277 | de++; | |
278 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino); | |
279 | strcpy(de->name,".."); | |
280 | ||
83005276 | 281 | kunmap_local(base); |
4309093e CH |
282 | dir_commit_chunk(page, 0, 2 * SYSV_DIRSIZE); |
283 | err = sysv_handle_dirsync(inode); | |
1da177e4 | 284 | fail: |
09cbfeaf | 285 | put_page(page); |
1da177e4 LT |
286 | return err; |
287 | } | |
288 | ||
289 | /* | |
290 | * routine to check that the specified directory is empty (for rmdir) | |
291 | */ | |
292 | int sysv_empty_dir(struct inode * inode) | |
293 | { | |
294 | struct super_block *sb = inode->i_sb; | |
295 | struct page *page = NULL; | |
296 | unsigned long i, npages = dir_pages(inode); | |
83005276 | 297 | char *kaddr; |
1da177e4 LT |
298 | |
299 | for (i = 0; i < npages; i++) { | |
83005276 | 300 | struct sysv_dir_entry *de; |
1da177e4 | 301 | |
8dd6c7b2 FDF |
302 | kaddr = dir_get_page(inode, i, &page); |
303 | if (IS_ERR(kaddr)) | |
1da177e4 LT |
304 | continue; |
305 | ||
1da177e4 | 306 | de = (struct sysv_dir_entry *)kaddr; |
09cbfeaf | 307 | kaddr += PAGE_SIZE-SYSV_DIRSIZE; |
1da177e4 LT |
308 | |
309 | for ( ;(char *)de <= kaddr; de++) { | |
310 | if (!de->inode) | |
311 | continue; | |
312 | /* check for . and .. */ | |
313 | if (de->name[0] != '.') | |
314 | goto not_empty; | |
315 | if (!de->name[1]) { | |
316 | if (de->inode == cpu_to_fs16(SYSV_SB(sb), | |
317 | inode->i_ino)) | |
318 | continue; | |
319 | goto not_empty; | |
320 | } | |
321 | if (de->name[1] != '.' || de->name[2]) | |
322 | goto not_empty; | |
323 | } | |
ede3ef5c | 324 | put_and_unmap_page(page, kaddr); |
1da177e4 LT |
325 | } |
326 | return 1; | |
327 | ||
328 | not_empty: | |
ede3ef5c | 329 | put_and_unmap_page(page, kaddr); |
1da177e4 LT |
330 | return 0; |
331 | } | |
332 | ||
333 | /* Releases the page */ | |
abb7c742 | 334 | int sysv_set_link(struct sysv_dir_entry *de, struct page *page, |
1da177e4 LT |
335 | struct inode *inode) |
336 | { | |
f4e420dc | 337 | struct inode *dir = page->mapping->host; |
4bb1a137 | 338 | loff_t pos = page_offset(page) + offset_in_page(de); |
1da177e4 LT |
339 | int err; |
340 | ||
341 | lock_page(page); | |
f4e420dc | 342 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
abb7c742 AV |
343 | if (err) { |
344 | unlock_page(page); | |
345 | return err; | |
346 | } | |
1da177e4 | 347 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); |
4309093e | 348 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
02027d42 | 349 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 | 350 | mark_inode_dirty(dir); |
abb7c742 | 351 | return sysv_handle_dirsync(inode); |
1da177e4 LT |
352 | } |
353 | ||
83005276 | 354 | /* |
ede3ef5c | 355 | * Calls to dir_get_page()/put_and_unmap_page() must be nested according to the |
83005276 FDF |
356 | * rules documented in mm/highmem.rst. |
357 | * | |
358 | * sysv_dotdot() acts as a call to dir_get_page() and must be treated | |
359 | * accordingly for nesting purposes. | |
360 | */ | |
8dd6c7b2 | 361 | struct sysv_dir_entry *sysv_dotdot(struct inode *dir, struct page **p) |
1da177e4 | 362 | { |
8dd6c7b2 | 363 | struct sysv_dir_entry *de = dir_get_page(dir, 0, p); |
1da177e4 | 364 | |
8dd6c7b2 FDF |
365 | if (IS_ERR(de)) |
366 | return NULL; | |
367 | /* ".." is the second directory entry */ | |
368 | return de + 1; | |
1da177e4 LT |
369 | } |
370 | ||
371 | ino_t sysv_inode_by_name(struct dentry *dentry) | |
372 | { | |
373 | struct page *page; | |
374 | struct sysv_dir_entry *de = sysv_find_entry (dentry, &page); | |
375 | ino_t res = 0; | |
376 | ||
377 | if (de) { | |
378 | res = fs16_to_cpu(SYSV_SB(dentry->d_sb), de->inode); | |
ede3ef5c | 379 | put_and_unmap_page(page, de); |
1da177e4 LT |
380 | } |
381 | return res; | |
382 | } |