Branch data Line data Source code
1 : : /*
2 : : * JFFS2 -- Journalling Flash File System, Version 2.
3 : : *
4 : : * Copyright © 2001-2007 Red Hat, Inc.
5 : : * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
6 : : *
7 : : * Created by David Woodhouse <dwmw2@infradead.org>
8 : : *
9 : : * For licensing information, see the file 'LICENCE' in this directory.
10 : : *
11 : : */
12 : :
13 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 : :
15 : : #include <linux/kernel.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/fs.h>
18 : : #include <linux/crc32.h>
19 : : #include <linux/jffs2.h>
20 : : #include "jffs2_fs_i.h"
21 : : #include "jffs2_fs_sb.h"
22 : : #include <linux/time.h>
23 : : #include "nodelist.h"
24 : :
25 : : static int jffs2_readdir (struct file *, struct dir_context *);
26 : :
27 : : static int jffs2_create (struct inode *,struct dentry *,umode_t,
28 : : bool);
29 : : static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
30 : : unsigned int);
31 : : static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
32 : : static int jffs2_unlink (struct inode *,struct dentry *);
33 : : static int jffs2_symlink (struct inode *,struct dentry *,const char *);
34 : : static int jffs2_mkdir (struct inode *,struct dentry *,umode_t);
35 : : static int jffs2_rmdir (struct inode *,struct dentry *);
36 : : static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t);
37 : : static int jffs2_rename (struct inode *, struct dentry *,
38 : : struct inode *, struct dentry *);
39 : :
40 : : const struct file_operations jffs2_dir_operations =
41 : : {
42 : : .read = generic_read_dir,
43 : : .iterate = jffs2_readdir,
44 : : .unlocked_ioctl=jffs2_ioctl,
45 : : .fsync = jffs2_fsync,
46 : : .llseek = generic_file_llseek,
47 : : };
48 : :
49 : :
50 : : const struct inode_operations jffs2_dir_inode_operations =
51 : : {
52 : : .create = jffs2_create,
53 : : .lookup = jffs2_lookup,
54 : : .link = jffs2_link,
55 : : .unlink = jffs2_unlink,
56 : : .symlink = jffs2_symlink,
57 : : .mkdir = jffs2_mkdir,
58 : : .rmdir = jffs2_rmdir,
59 : : .mknod = jffs2_mknod,
60 : : .rename = jffs2_rename,
61 : : .get_acl = jffs2_get_acl,
62 : : .set_acl = jffs2_set_acl,
63 : : .setattr = jffs2_setattr,
64 : : .setxattr = jffs2_setxattr,
65 : : .getxattr = jffs2_getxattr,
66 : : .listxattr = jffs2_listxattr,
67 : : .removexattr = jffs2_removexattr
68 : : };
69 : :
70 : : /***********************************************************************/
71 : :
72 : :
73 : : /* We keep the dirent list sorted in increasing order of name hash,
74 : : and we use the same hash function as the dentries. Makes this
75 : : nice and simple
76 : : */
77 : 0 : static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
78 : : unsigned int flags)
79 : : {
80 : : struct jffs2_inode_info *dir_f;
81 : : struct jffs2_full_dirent *fd = NULL, *fd_list;
82 : : uint32_t ino = 0;
83 : : struct inode *inode = NULL;
84 : :
85 : : jffs2_dbg(1, "jffs2_lookup()\n");
86 : :
87 [ # # ]: 0 : if (target->d_name.len > JFFS2_MAX_NAME_LEN)
88 : : return ERR_PTR(-ENAMETOOLONG);
89 : :
90 : : dir_f = JFFS2_INODE_INFO(dir_i);
91 : :
92 : 0 : mutex_lock(&dir_f->sem);
93 : :
94 : : /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
95 [ # # ][ # # ]: 0 : for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) {
96 [ # # ][ # # ]: 0 : if (fd_list->nhash == target->d_name.hash &&
97 [ # # ][ # # ]: 0 : (!fd || fd_list->version > fd->version) &&
98 [ # # ]: 0 : strlen(fd_list->name) == target->d_name.len &&
99 : 0 : !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) {
100 : : fd = fd_list;
101 : : }
102 : : }
103 [ # # ]: 0 : if (fd)
104 : 0 : ino = fd->ino;
105 : 0 : mutex_unlock(&dir_f->sem);
106 [ # # ]: 0 : if (ino) {
107 : 0 : inode = jffs2_iget(dir_i->i_sb, ino);
108 [ # # ]: 0 : if (IS_ERR(inode))
109 : 0 : pr_warn("iget() failed for ino #%u\n", ino);
110 : : }
111 : :
112 : 0 : return d_splice_alias(inode, target);
113 : : }
114 : :
115 : : /***********************************************************************/
116 : :
117 : :
118 : 0 : static int jffs2_readdir(struct file *file, struct dir_context *ctx)
119 : : {
120 : : struct inode *inode = file_inode(file);
121 : : struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
122 : : struct jffs2_full_dirent *fd;
123 : : unsigned long curofs = 1;
124 : :
125 : : jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino);
126 : :
127 [ # # ]: 0 : if (!dir_emit_dots(file, ctx))
128 : : return 0;
129 : :
130 : 0 : mutex_lock(&f->sem);
131 [ # # ]: 0 : for (fd = f->dents; fd; fd = fd->next) {
132 : 0 : curofs++;
133 : : /* First loop: curofs = 2; pos = 2 */
134 [ # # ]: 0 : if (curofs < ctx->pos) {
135 : : jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
136 : : fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos);
137 : 0 : continue;
138 : : }
139 [ # # ]: 0 : if (!fd->ino) {
140 : : jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n",
141 : : fd->name);
142 : 0 : ctx->pos++;
143 : 0 : continue;
144 : : }
145 : : jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n",
146 : : (unsigned long)ctx->pos, fd->name, fd->ino, fd->type);
147 [ # # ]: 0 : if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type))
148 : : break;
149 : 0 : ctx->pos++;
150 : : }
151 : 0 : mutex_unlock(&f->sem);
152 : 0 : return 0;
153 : : }
154 : :
155 : : /***********************************************************************/
156 : :
157 : :
158 : 0 : static int jffs2_create(struct inode *dir_i, struct dentry *dentry,
159 : : umode_t mode, bool excl)
160 : : {
161 : : struct jffs2_raw_inode *ri;
162 : : struct jffs2_inode_info *f, *dir_f;
163 : : struct jffs2_sb_info *c;
164 : : struct inode *inode;
165 : : int ret;
166 : :
167 : 0 : ri = jffs2_alloc_raw_inode();
168 [ # # ]: 0 : if (!ri)
169 : : return -ENOMEM;
170 : :
171 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
172 : :
173 : : jffs2_dbg(1, "%s()\n", __func__);
174 : :
175 : 0 : inode = jffs2_new_inode(dir_i, mode, ri);
176 : :
177 [ # # ]: 0 : if (IS_ERR(inode)) {
178 : : jffs2_dbg(1, "jffs2_new_inode() failed\n");
179 : 0 : jffs2_free_raw_inode(ri);
180 : 0 : return PTR_ERR(inode);
181 : : }
182 : :
183 : 0 : inode->i_op = &jffs2_file_inode_operations;
184 : 0 : inode->i_fop = &jffs2_file_operations;
185 : 0 : inode->i_mapping->a_ops = &jffs2_file_address_operations;
186 : 0 : inode->i_mapping->nrpages = 0;
187 : :
188 : 0 : f = JFFS2_INODE_INFO(inode);
189 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
190 : :
191 : : /* jffs2_do_create() will want to lock it, _after_ reserving
192 : : space and taking c-alloc_sem. If we keep it locked here,
193 : : lockdep gets unhappy (although it's a false positive;
194 : : nothing else will be looking at this inode yet so there's
195 : : no chance of AB-BA deadlock involving its f->sem). */
196 : 0 : mutex_unlock(&f->sem);
197 : :
198 : 0 : ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name);
199 [ # # ]: 0 : if (ret)
200 : : goto fail;
201 : :
202 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
203 : :
204 : 0 : jffs2_free_raw_inode(ri);
205 : :
206 : : jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
207 : : __func__, inode->i_ino, inode->i_mode, inode->i_nlink,
208 : : f->inocache->pino_nlink, inode->i_mapping->nrpages);
209 : :
210 : 0 : unlock_new_inode(inode);
211 : 0 : d_instantiate(dentry, inode);
212 : 0 : return 0;
213 : :
214 : : fail:
215 : 0 : iget_failed(inode);
216 : 0 : jffs2_free_raw_inode(ri);
217 : 0 : return ret;
218 : : }
219 : :
220 : : /***********************************************************************/
221 : :
222 : :
223 : 0 : static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
224 : : {
225 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
226 : 0 : struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
227 : 0 : struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode);
228 : : int ret;
229 : 0 : uint32_t now = get_seconds();
230 : :
231 : 0 : ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
232 : 0 : dentry->d_name.len, dead_f, now);
233 [ # # ]: 0 : if (dead_f->inocache)
234 : 0 : set_nlink(dentry->d_inode, dead_f->inocache->pino_nlink);
235 [ # # ]: 0 : if (!ret)
236 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
237 : 0 : return ret;
238 : : }
239 : : /***********************************************************************/
240 : :
241 : :
242 : 0 : static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
243 : : {
244 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb);
245 : : struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
246 : 0 : struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
247 : : int ret;
248 : : uint8_t type;
249 : : uint32_t now;
250 : :
251 : : /* Don't let people make hard links to bad inodes. */
252 [ # # ]: 0 : if (!f->inocache)
253 : : return -EIO;
254 : :
255 [ # # ]: 0 : if (S_ISDIR(old_dentry->d_inode->i_mode))
256 : : return -EPERM;
257 : :
258 : : /* XXX: This is ugly */
259 : 0 : type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
260 [ # # ]: 0 : if (!type) type = DT_REG;
261 : :
262 : 0 : now = get_seconds();
263 : 0 : ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now);
264 : :
265 [ # # ]: 0 : if (!ret) {
266 : 0 : mutex_lock(&f->sem);
267 : 0 : set_nlink(old_dentry->d_inode, ++f->inocache->pino_nlink);
268 : 0 : mutex_unlock(&f->sem);
269 : 0 : d_instantiate(dentry, old_dentry->d_inode);
270 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
271 : 0 : ihold(old_dentry->d_inode);
272 : : }
273 : 0 : return ret;
274 : : }
275 : :
276 : : /***********************************************************************/
277 : :
278 : 0 : static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target)
279 : : {
280 : : struct jffs2_inode_info *f, *dir_f;
281 : : struct jffs2_sb_info *c;
282 : : struct inode *inode;
283 : : struct jffs2_raw_inode *ri;
284 : : struct jffs2_raw_dirent *rd;
285 : : struct jffs2_full_dnode *fn;
286 : : struct jffs2_full_dirent *fd;
287 : : int namelen;
288 : : uint32_t alloclen;
289 : 0 : int ret, targetlen = strlen(target);
290 : :
291 : : /* FIXME: If you care. We'd need to use frags for the target
292 : : if it grows much more than this */
293 [ # # ]: 0 : if (targetlen > 254)
294 : : return -ENAMETOOLONG;
295 : :
296 : 0 : ri = jffs2_alloc_raw_inode();
297 : :
298 [ # # ]: 0 : if (!ri)
299 : : return -ENOMEM;
300 : :
301 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
302 : :
303 : : /* Try to reserve enough space for both node and dirent.
304 : : * Just the node will do for now, though
305 : : */
306 : 0 : namelen = dentry->d_name.len;
307 : 0 : ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
308 : : ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
309 : :
310 [ # # ]: 0 : if (ret) {
311 : 0 : jffs2_free_raw_inode(ri);
312 : 0 : return ret;
313 : : }
314 : :
315 : 0 : inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri);
316 : :
317 [ # # ]: 0 : if (IS_ERR(inode)) {
318 : 0 : jffs2_free_raw_inode(ri);
319 : 0 : jffs2_complete_reservation(c);
320 : 0 : return PTR_ERR(inode);
321 : : }
322 : :
323 : 0 : inode->i_op = &jffs2_symlink_inode_operations;
324 : :
325 : 0 : f = JFFS2_INODE_INFO(inode);
326 : :
327 : 0 : inode->i_size = targetlen;
328 : 0 : ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
329 : 0 : ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
330 : 0 : ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
331 : :
332 : 0 : ri->compr = JFFS2_COMPR_NONE;
333 : 0 : ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
334 : 0 : ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
335 : :
336 : 0 : fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL);
337 : :
338 : 0 : jffs2_free_raw_inode(ri);
339 : :
340 [ # # ]: 0 : if (IS_ERR(fn)) {
341 : : /* Eeek. Wave bye bye */
342 : 0 : mutex_unlock(&f->sem);
343 : 0 : jffs2_complete_reservation(c);
344 : : ret = PTR_ERR(fn);
345 : 0 : goto fail;
346 : : }
347 : :
348 : : /* We use f->target field to store the target path. */
349 : 0 : f->target = kmemdup(target, targetlen + 1, GFP_KERNEL);
350 [ # # ]: 0 : if (!f->target) {
351 : 0 : pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1);
352 : 0 : mutex_unlock(&f->sem);
353 : 0 : jffs2_complete_reservation(c);
354 : : ret = -ENOMEM;
355 : 0 : goto fail;
356 : : }
357 : :
358 : : jffs2_dbg(1, "%s(): symlink's target '%s' cached\n",
359 : : __func__, (char *)f->target);
360 : :
361 : : /* No data here. Only a metadata node, which will be
362 : : obsoleted by the first data write
363 : : */
364 : 0 : f->metadata = fn;
365 : 0 : mutex_unlock(&f->sem);
366 : :
367 : 0 : jffs2_complete_reservation(c);
368 : :
369 : 0 : ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
370 [ # # ]: 0 : if (ret)
371 : : goto fail;
372 : :
373 : 0 : ret = jffs2_init_acl_post(inode);
374 [ # # ]: 0 : if (ret)
375 : : goto fail;
376 : :
377 : 0 : ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
378 : : ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
379 [ # # ]: 0 : if (ret)
380 : : goto fail;
381 : :
382 : 0 : rd = jffs2_alloc_raw_dirent();
383 [ # # ]: 0 : if (!rd) {
384 : : /* Argh. Now we treat it like a normal delete */
385 : 0 : jffs2_complete_reservation(c);
386 : : ret = -ENOMEM;
387 : 0 : goto fail;
388 : : }
389 : :
390 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
391 : 0 : mutex_lock(&dir_f->sem);
392 : :
393 : 0 : rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
394 : 0 : rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
395 : 0 : rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
396 : 0 : rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
397 : :
398 : 0 : rd->pino = cpu_to_je32(dir_i->i_ino);
399 : 0 : rd->version = cpu_to_je32(++dir_f->highest_version);
400 : 0 : rd->ino = cpu_to_je32(inode->i_ino);
401 : 0 : rd->mctime = cpu_to_je32(get_seconds());
402 : 0 : rd->nsize = namelen;
403 : 0 : rd->type = DT_LNK;
404 : 0 : rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
405 : 0 : rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
406 : :
407 : 0 : fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
408 : :
409 [ # # ]: 0 : if (IS_ERR(fd)) {
410 : : /* dirent failed to write. Delete the inode normally
411 : : as if it were the final unlink() */
412 : 0 : jffs2_complete_reservation(c);
413 : 0 : jffs2_free_raw_dirent(rd);
414 : 0 : mutex_unlock(&dir_f->sem);
415 : : ret = PTR_ERR(fd);
416 : 0 : goto fail;
417 : : }
418 : :
419 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
420 : :
421 : 0 : jffs2_free_raw_dirent(rd);
422 : :
423 : : /* Link the fd into the inode's list, obsoleting an old
424 : : one if necessary. */
425 : 0 : jffs2_add_fd_to_list(c, fd, &dir_f->dents);
426 : :
427 : 0 : mutex_unlock(&dir_f->sem);
428 : 0 : jffs2_complete_reservation(c);
429 : :
430 : 0 : unlock_new_inode(inode);
431 : 0 : d_instantiate(dentry, inode);
432 : 0 : return 0;
433 : :
434 : : fail:
435 : 0 : iget_failed(inode);
436 : 0 : return ret;
437 : : }
438 : :
439 : :
440 : 0 : static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode)
441 : : {
442 : : struct jffs2_inode_info *f, *dir_f;
443 : : struct jffs2_sb_info *c;
444 : : struct inode *inode;
445 : : struct jffs2_raw_inode *ri;
446 : : struct jffs2_raw_dirent *rd;
447 : : struct jffs2_full_dnode *fn;
448 : : struct jffs2_full_dirent *fd;
449 : : int namelen;
450 : : uint32_t alloclen;
451 : : int ret;
452 : :
453 : 0 : mode |= S_IFDIR;
454 : :
455 : 0 : ri = jffs2_alloc_raw_inode();
456 [ # # ]: 0 : if (!ri)
457 : : return -ENOMEM;
458 : :
459 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
460 : :
461 : : /* Try to reserve enough space for both node and dirent.
462 : : * Just the node will do for now, though
463 : : */
464 : 0 : namelen = dentry->d_name.len;
465 : 0 : ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
466 : : JFFS2_SUMMARY_INODE_SIZE);
467 : :
468 [ # # ]: 0 : if (ret) {
469 : 0 : jffs2_free_raw_inode(ri);
470 : 0 : return ret;
471 : : }
472 : :
473 : 0 : inode = jffs2_new_inode(dir_i, mode, ri);
474 : :
475 [ # # ]: 0 : if (IS_ERR(inode)) {
476 : 0 : jffs2_free_raw_inode(ri);
477 : 0 : jffs2_complete_reservation(c);
478 : 0 : return PTR_ERR(inode);
479 : : }
480 : :
481 : 0 : inode->i_op = &jffs2_dir_inode_operations;
482 : 0 : inode->i_fop = &jffs2_dir_operations;
483 : :
484 : 0 : f = JFFS2_INODE_INFO(inode);
485 : :
486 : : /* Directories get nlink 2 at start */
487 : 0 : set_nlink(inode, 2);
488 : : /* but ic->pino_nlink is the parent ino# */
489 : 0 : f->inocache->pino_nlink = dir_i->i_ino;
490 : :
491 : 0 : ri->data_crc = cpu_to_je32(0);
492 : 0 : ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
493 : :
494 : 0 : fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
495 : :
496 : 0 : jffs2_free_raw_inode(ri);
497 : :
498 [ # # ]: 0 : if (IS_ERR(fn)) {
499 : : /* Eeek. Wave bye bye */
500 : 0 : mutex_unlock(&f->sem);
501 : 0 : jffs2_complete_reservation(c);
502 : : ret = PTR_ERR(fn);
503 : 0 : goto fail;
504 : : }
505 : : /* No data here. Only a metadata node, which will be
506 : : obsoleted by the first data write
507 : : */
508 : 0 : f->metadata = fn;
509 : 0 : mutex_unlock(&f->sem);
510 : :
511 : 0 : jffs2_complete_reservation(c);
512 : :
513 : 0 : ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
514 [ # # ]: 0 : if (ret)
515 : : goto fail;
516 : :
517 : 0 : ret = jffs2_init_acl_post(inode);
518 [ # # ]: 0 : if (ret)
519 : : goto fail;
520 : :
521 : 0 : ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
522 : : ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
523 [ # # ]: 0 : if (ret)
524 : : goto fail;
525 : :
526 : 0 : rd = jffs2_alloc_raw_dirent();
527 [ # # ]: 0 : if (!rd) {
528 : : /* Argh. Now we treat it like a normal delete */
529 : 0 : jffs2_complete_reservation(c);
530 : : ret = -ENOMEM;
531 : 0 : goto fail;
532 : : }
533 : :
534 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
535 : 0 : mutex_lock(&dir_f->sem);
536 : :
537 : 0 : rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
538 : 0 : rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
539 : 0 : rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
540 : 0 : rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
541 : :
542 : 0 : rd->pino = cpu_to_je32(dir_i->i_ino);
543 : 0 : rd->version = cpu_to_je32(++dir_f->highest_version);
544 : 0 : rd->ino = cpu_to_je32(inode->i_ino);
545 : 0 : rd->mctime = cpu_to_je32(get_seconds());
546 : 0 : rd->nsize = namelen;
547 : 0 : rd->type = DT_DIR;
548 : 0 : rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
549 : 0 : rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
550 : :
551 : 0 : fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
552 : :
553 [ # # ]: 0 : if (IS_ERR(fd)) {
554 : : /* dirent failed to write. Delete the inode normally
555 : : as if it were the final unlink() */
556 : 0 : jffs2_complete_reservation(c);
557 : 0 : jffs2_free_raw_dirent(rd);
558 : 0 : mutex_unlock(&dir_f->sem);
559 : : ret = PTR_ERR(fd);
560 : 0 : goto fail;
561 : : }
562 : :
563 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
564 : 0 : inc_nlink(dir_i);
565 : :
566 : 0 : jffs2_free_raw_dirent(rd);
567 : :
568 : : /* Link the fd into the inode's list, obsoleting an old
569 : : one if necessary. */
570 : 0 : jffs2_add_fd_to_list(c, fd, &dir_f->dents);
571 : :
572 : 0 : mutex_unlock(&dir_f->sem);
573 : 0 : jffs2_complete_reservation(c);
574 : :
575 : 0 : unlock_new_inode(inode);
576 : 0 : d_instantiate(dentry, inode);
577 : 0 : return 0;
578 : :
579 : : fail:
580 : 0 : iget_failed(inode);
581 : 0 : return ret;
582 : : }
583 : :
584 : 0 : static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
585 : : {
586 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
587 : 0 : struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
588 : 0 : struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
589 : : struct jffs2_full_dirent *fd;
590 : : int ret;
591 : 0 : uint32_t now = get_seconds();
592 : :
593 [ # # ]: 0 : for (fd = f->dents ; fd; fd = fd->next) {
594 [ # # ]: 0 : if (fd->ino)
595 : : return -ENOTEMPTY;
596 : : }
597 : :
598 : 0 : ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
599 : 0 : dentry->d_name.len, f, now);
600 [ # # ]: 0 : if (!ret) {
601 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
602 : 0 : clear_nlink(dentry->d_inode);
603 : 0 : drop_nlink(dir_i);
604 : : }
605 : 0 : return ret;
606 : : }
607 : :
608 : 0 : static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev)
609 : : {
610 : : struct jffs2_inode_info *f, *dir_f;
611 : : struct jffs2_sb_info *c;
612 : : struct inode *inode;
613 : : struct jffs2_raw_inode *ri;
614 : : struct jffs2_raw_dirent *rd;
615 : : struct jffs2_full_dnode *fn;
616 : : struct jffs2_full_dirent *fd;
617 : : int namelen;
618 : : union jffs2_device_node dev;
619 : : int devlen = 0;
620 : : uint32_t alloclen;
621 : : int ret;
622 : :
623 : : if (!new_valid_dev(rdev))
624 : : return -EINVAL;
625 : :
626 : 0 : ri = jffs2_alloc_raw_inode();
627 [ # # ]: 0 : if (!ri)
628 : : return -ENOMEM;
629 : :
630 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
631 : :
632 [ # # ]: 0 : if (S_ISBLK(mode) || S_ISCHR(mode))
633 : : devlen = jffs2_encode_dev(&dev, rdev);
634 : :
635 : : /* Try to reserve enough space for both node and dirent.
636 : : * Just the node will do for now, though
637 : : */
638 : 0 : namelen = dentry->d_name.len;
639 : 0 : ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
640 : : ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
641 : :
642 [ # # ]: 0 : if (ret) {
643 : 0 : jffs2_free_raw_inode(ri);
644 : 0 : return ret;
645 : : }
646 : :
647 : 0 : inode = jffs2_new_inode(dir_i, mode, ri);
648 : :
649 [ # # ]: 0 : if (IS_ERR(inode)) {
650 : 0 : jffs2_free_raw_inode(ri);
651 : 0 : jffs2_complete_reservation(c);
652 : 0 : return PTR_ERR(inode);
653 : : }
654 : 0 : inode->i_op = &jffs2_file_inode_operations;
655 : 0 : init_special_inode(inode, inode->i_mode, rdev);
656 : :
657 : 0 : f = JFFS2_INODE_INFO(inode);
658 : :
659 : 0 : ri->dsize = ri->csize = cpu_to_je32(devlen);
660 : 0 : ri->totlen = cpu_to_je32(sizeof(*ri) + devlen);
661 : 0 : ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
662 : :
663 : 0 : ri->compr = JFFS2_COMPR_NONE;
664 : 0 : ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen));
665 : 0 : ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
666 : :
667 : 0 : fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
668 : :
669 : 0 : jffs2_free_raw_inode(ri);
670 : :
671 [ # # ]: 0 : if (IS_ERR(fn)) {
672 : : /* Eeek. Wave bye bye */
673 : 0 : mutex_unlock(&f->sem);
674 : 0 : jffs2_complete_reservation(c);
675 : : ret = PTR_ERR(fn);
676 : 0 : goto fail;
677 : : }
678 : : /* No data here. Only a metadata node, which will be
679 : : obsoleted by the first data write
680 : : */
681 : 0 : f->metadata = fn;
682 : 0 : mutex_unlock(&f->sem);
683 : :
684 : 0 : jffs2_complete_reservation(c);
685 : :
686 : 0 : ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
687 [ # # ]: 0 : if (ret)
688 : : goto fail;
689 : :
690 : 0 : ret = jffs2_init_acl_post(inode);
691 [ # # ]: 0 : if (ret)
692 : : goto fail;
693 : :
694 : 0 : ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
695 : : ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
696 [ # # ]: 0 : if (ret)
697 : : goto fail;
698 : :
699 : 0 : rd = jffs2_alloc_raw_dirent();
700 [ # # ]: 0 : if (!rd) {
701 : : /* Argh. Now we treat it like a normal delete */
702 : 0 : jffs2_complete_reservation(c);
703 : : ret = -ENOMEM;
704 : 0 : goto fail;
705 : : }
706 : :
707 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
708 : 0 : mutex_lock(&dir_f->sem);
709 : :
710 : 0 : rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
711 : 0 : rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
712 : 0 : rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
713 : 0 : rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
714 : :
715 : 0 : rd->pino = cpu_to_je32(dir_i->i_ino);
716 : 0 : rd->version = cpu_to_je32(++dir_f->highest_version);
717 : 0 : rd->ino = cpu_to_je32(inode->i_ino);
718 : 0 : rd->mctime = cpu_to_je32(get_seconds());
719 : 0 : rd->nsize = namelen;
720 : :
721 : : /* XXX: This is ugly. */
722 : 0 : rd->type = (mode & S_IFMT) >> 12;
723 : :
724 : 0 : rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
725 : 0 : rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
726 : :
727 : 0 : fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
728 : :
729 [ # # ]: 0 : if (IS_ERR(fd)) {
730 : : /* dirent failed to write. Delete the inode normally
731 : : as if it were the final unlink() */
732 : 0 : jffs2_complete_reservation(c);
733 : 0 : jffs2_free_raw_dirent(rd);
734 : 0 : mutex_unlock(&dir_f->sem);
735 : : ret = PTR_ERR(fd);
736 : 0 : goto fail;
737 : : }
738 : :
739 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
740 : :
741 : 0 : jffs2_free_raw_dirent(rd);
742 : :
743 : : /* Link the fd into the inode's list, obsoleting an old
744 : : one if necessary. */
745 : 0 : jffs2_add_fd_to_list(c, fd, &dir_f->dents);
746 : :
747 : 0 : mutex_unlock(&dir_f->sem);
748 : 0 : jffs2_complete_reservation(c);
749 : :
750 : 0 : unlock_new_inode(inode);
751 : 0 : d_instantiate(dentry, inode);
752 : 0 : return 0;
753 : :
754 : : fail:
755 : 0 : iget_failed(inode);
756 : 0 : return ret;
757 : : }
758 : :
759 : 0 : static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
760 : : struct inode *new_dir_i, struct dentry *new_dentry)
761 : : {
762 : : int ret;
763 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
764 : : struct jffs2_inode_info *victim_f = NULL;
765 : : uint8_t type;
766 : : uint32_t now;
767 : :
768 : : /* The VFS will check for us and prevent trying to rename a
769 : : * file over a directory and vice versa, but if it's a directory,
770 : : * the VFS can't check whether the victim is empty. The filesystem
771 : : * needs to do that for itself.
772 : : */
773 [ # # ]: 0 : if (new_dentry->d_inode) {
774 : 0 : victim_f = JFFS2_INODE_INFO(new_dentry->d_inode);
775 [ # # ]: 0 : if (S_ISDIR(new_dentry->d_inode->i_mode)) {
776 : : struct jffs2_full_dirent *fd;
777 : :
778 : 0 : mutex_lock(&victim_f->sem);
779 [ # # ]: 0 : for (fd = victim_f->dents; fd; fd = fd->next) {
780 [ # # ]: 0 : if (fd->ino) {
781 : 0 : mutex_unlock(&victim_f->sem);
782 : 0 : return -ENOTEMPTY;
783 : : }
784 : : }
785 : 0 : mutex_unlock(&victim_f->sem);
786 : : }
787 : : }
788 : :
789 : : /* XXX: We probably ought to alloc enough space for
790 : : both nodes at the same time. Writing the new link,
791 : : then getting -ENOSPC, is quite bad :)
792 : : */
793 : :
794 : : /* Make a hard link */
795 : :
796 : : /* XXX: This is ugly */
797 : 0 : type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
798 [ # # ]: 0 : if (!type) type = DT_REG;
799 : :
800 : 0 : now = get_seconds();
801 : 0 : ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
802 : 0 : old_dentry->d_inode->i_ino, type,
803 : 0 : new_dentry->d_name.name, new_dentry->d_name.len, now);
804 : :
805 [ # # ]: 0 : if (ret)
806 : : return ret;
807 : :
808 [ # # ]: 0 : if (victim_f) {
809 : : /* There was a victim. Kill it off nicely */
810 [ # # ]: 0 : if (S_ISDIR(new_dentry->d_inode->i_mode))
811 : 0 : clear_nlink(new_dentry->d_inode);
812 : : else
813 : 0 : drop_nlink(new_dentry->d_inode);
814 : : /* Don't oops if the victim was a dirent pointing to an
815 : : inode which didn't exist. */
816 [ # # ]: 0 : if (victim_f->inocache) {
817 : 0 : mutex_lock(&victim_f->sem);
818 [ # # ]: 0 : if (S_ISDIR(new_dentry->d_inode->i_mode))
819 : 0 : victim_f->inocache->pino_nlink = 0;
820 : : else
821 : 0 : victim_f->inocache->pino_nlink--;
822 : 0 : mutex_unlock(&victim_f->sem);
823 : : }
824 : : }
825 : :
826 : : /* If it was a directory we moved, and there was no victim,
827 : : increase i_nlink on its new parent */
828 [ # # ][ # # ]: 0 : if (S_ISDIR(old_dentry->d_inode->i_mode) && !victim_f)
829 : 0 : inc_nlink(new_dir_i);
830 : :
831 : : /* Unlink the original */
832 : 0 : ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
833 : 0 : old_dentry->d_name.name, old_dentry->d_name.len, NULL, now);
834 : :
835 : : /* We don't touch inode->i_nlink */
836 : :
837 [ # # ]: 0 : if (ret) {
838 : : /* Oh shit. We really ought to make a single node which can do both atomically */
839 : 0 : struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
840 : 0 : mutex_lock(&f->sem);
841 : 0 : inc_nlink(old_dentry->d_inode);
842 [ # # ][ # # ]: 0 : if (f->inocache && !S_ISDIR(old_dentry->d_inode->i_mode))
843 : 0 : f->inocache->pino_nlink++;
844 : 0 : mutex_unlock(&f->sem);
845 : :
846 : 0 : pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
847 : : __func__, ret);
848 : : /* Might as well let the VFS know */
849 : 0 : d_instantiate(new_dentry, old_dentry->d_inode);
850 : 0 : ihold(old_dentry->d_inode);
851 : 0 : new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
852 : 0 : return ret;
853 : : }
854 : :
855 [ # # ]: 0 : if (S_ISDIR(old_dentry->d_inode->i_mode))
856 : 0 : drop_nlink(old_dir_i);
857 : :
858 : 0 : new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now);
859 : :
860 : 0 : return 0;
861 : : }
862 : :
|
