Whamcloud - gitweb
df8edbd76d6c71df09b60c8230d1dba96d72a34e
[fs/lustre-release.git] / lustre / llite / namei.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * This code is issued under the GNU General Public License.
5  * See the file COPYING in this distribution
6  *
7  * Copyright (C) 1992, 1993, 1994, 1995
8  * Remy Card (card@masi.ibp.fr)
9  * Laboratoire MASI - Institut Blaise Pascal
10  * Universite Pierre et Marie Curie (Paris VI)
11  *
12  *  from
13  *
14  *  linux/fs/ext2/namei.c
15  *
16  *  Copyright (C) 1991, 1992  Linus Torvalds
17  *
18  *  Big-endian to little-endian byte-swapping/bitmaps by
19  *        David S. Miller (davem@caip.rutgers.edu), 1995
20  *  Directory entry file type support and forward compatibility hooks
21  *      for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
22  *
23  *  Changes for use in OBDFS
24  *  Copyright (c) 1999, Seagate Technology Inc.
25  *  Copyright (C) 2001, Cluster File Systems, Inc.
26  *                       Rewritten based on recent ext2 page cache use.
27  *
28  */
29
30 #include <linux/fs.h>
31 #include <linux/locks.h>
32 #include <linux/quotaops.h>
33
34 #define DEBUG_SUBSYSTEM S_LLITE
35
36 #include <linux/obd_support.h>
37 #include <linux/lustre_lite.h>
38 #include <linux/lustre_dlm.h>
39 extern struct address_space_operations ll_aops;
40
41 /* from super.c */
42 extern void ll_change_inode(struct inode *inode);
43 extern int ll_setattr(struct dentry *de, struct iattr *attr);
44
45 /* from dir.c */
46 extern int ll_add_link (struct dentry *dentry, struct inode *inode);
47 obd_id ll_inode_by_name(struct inode * dir, struct dentry *dentry, int *typ);
48 int ext2_make_empty(struct inode *inode, struct inode *parent);
49 struct ext2_dir_entry_2 * ext2_find_entry (struct inode * dir,
50                    struct dentry *dentry, struct page ** res_page);
51 int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page );
52 int ext2_empty_dir (struct inode * inode);
53 struct ext2_dir_entry_2 * ext2_dotdot (struct inode *dir, struct page **p);
54 void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
55                    struct page *page, struct inode *inode);
56
57 /*
58  * Couple of helper functions - make the code slightly cleaner.
59  */
60 static inline void ext2_inc_count(struct inode *inode)
61 {
62         inode->i_nlink++;
63 }
64
65 /* postpone the disk update until the inode really goes away */
66 static inline void ext2_dec_count(struct inode *inode)
67 {
68         inode->i_nlink--;
69 }
70
71 static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
72 {
73         int err;
74         err = ll_add_link(dentry, inode);
75         if (!err) {
76                 d_instantiate(dentry, inode);
77                 return 0;
78         }
79         ext2_dec_count(inode);
80         iput(inode);
81         return err;
82 }
83
84 /* methods */
85 static int ll_find_inode(struct inode *inode, unsigned long ino, void *opaque)
86 {
87         struct mds_body *body = (struct mds_body *)opaque;
88
89         if (inode->i_generation != body->generation)
90                 return 0;
91
92         return 1;
93 }
94
95 extern struct dentry_operations ll_d_ops;
96
97 int ll_lock(struct inode *dir, struct dentry *dentry,
98             struct lookup_intent *it, struct lustre_handle *lockh)
99 {
100         struct ll_sb_info *sbi = ll_i2sbi(dir);
101         int err, lock_mode;
102
103         if ((it->it_op & (IT_CREAT | IT_MKDIR | IT_SYMLINK | IT_SETATTR |
104                           IT_MKNOD)))
105                 lock_mode = LCK_PW;
106         else if (it->it_op & (IT_READDIR | IT_GETATTR | IT_OPEN | IT_UNLINK |
107                               IT_RMDIR | IT_RENAME | IT_RENAME2))
108                 lock_mode = LCK_PR;
109         else if (it->it_op & IT_LOOKUP)
110                 lock_mode = LCK_CR;
111         else {
112                 LBUG();
113                 RETURN(-1);
114         }
115
116         err = mdc_enqueue(&sbi->ll_mdc_conn, LDLM_MDSINTENT, it, lock_mode, dir,
117                           dentry, lockh, 0, NULL, 0, dir, sizeof(*dir));
118
119         RETURN(err);
120 }
121
122 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
123 {
124         ENTRY;
125
126         ldlm_lock_decref(lockh, mode);
127
128         RETURN(0);
129 }
130
131 static struct dentry *ll_lookup2(struct inode * dir, struct dentry *dentry,
132                                  struct lookup_intent *it)
133 {
134         struct ptlrpc_request *request = NULL;
135         struct inode * inode = NULL;
136         struct ll_sb_info *sbi = ll_i2sbi(dir);
137         struct ll_inode_md md;
138         struct lustre_handle lockh;
139         int err, type, offset;
140         struct lookup_intent lookup_it = { IT_LOOKUP };
141         obd_id ino;
142
143         ENTRY;
144
145         if (it == NULL) {
146                 it = &lookup_it;
147                 dentry->d_it = it;
148         }
149
150         CDEBUG(D_INFO, "name: %*s, intent op: %d\n", dentry->d_name.len,
151                dentry->d_name.name, it->it_op);
152
153         if (dentry->d_name.len > EXT2_NAME_LEN)
154                 RETURN(ERR_PTR(-ENAMETOOLONG));
155
156         err = ll_lock(dir, dentry, it, &lockh);
157         if (err < 0) {
158                 /* FIXME: Mike LBUG() can disappear the moment that 
159                  *   ll_lock has sane interrupt behavior 
160                  */
161                 LBUG();
162                 RETURN(ERR_PTR(err));
163         }
164         memcpy(it->it_lock_handle, &lockh, sizeof(lockh));
165
166         if ((it->it_op & (IT_CREAT | IT_MKDIR | IT_SYMLINK | IT_MKNOD)) &&
167             it->it_disposition && !it->it_status)
168                 GOTO(negative, NULL);
169
170         if ((it->it_op & (IT_RENAME | IT_GETATTR | IT_UNLINK | IT_RMDIR |
171                           IT_SETATTR | IT_LOOKUP)) && 
172             it->it_disposition && it->it_status)
173                 GOTO(negative, NULL);
174
175         request = (struct ptlrpc_request *)it->it_data;
176         if (!it->it_disposition) {
177                 struct ll_inode_info *lli = ll_i2info(dir);
178                 memcpy(&lli->lli_intent_lock_handle, &lockh, sizeof(lockh));
179
180                 ino = ll_inode_by_name(dir, dentry, &type);
181 #warning FIXME: handle negative inode case (see old ll_lookup)
182
183                 err = mdc_getattr(&sbi->ll_mdc_conn, ino, type,
184                                   OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, 0, &request);
185                 if (err) {
186                         CERROR("failure %d inode %Ld\n", err, (long long)ino);
187                         ptlrpc_free_req(request);
188                         RETURN(ERR_PTR(-abs(err)));
189                 }
190                 offset = 0;
191         } else if (it->it_op == IT_RENAME2) {
192                 inode = ((struct dentry *)(it->it_data))->d_inode;
193                 GOTO(out_req, NULL); 
194         } else {
195                 offset = 1;
196         }
197
198         md.body = lustre_msg_buf(request->rq_repmsg, offset);
199         if (S_ISREG(md.body->mode)) {
200                 if (request->rq_repmsg->bufcount < offset + 1)
201                         LBUG();
202                 md.md = lustre_msg_buf(request->rq_repmsg, offset + 1);
203         } else
204                 md.md = NULL;
205
206         /* No rpc's happen during iget4, -ENOMEM's are possible */
207         inode = iget4(dir->i_sb, ino, ll_find_inode, &md);
208         if (it->it_op & IT_RENAME)
209                 it->it_data = dentry;
210
211  out_req:
212         ptlrpc_free_req(request);
213         if (!inode || IS_ERR(inode)) { 
214                 ll_intent_release(dentry); 
215                 RETURN(ERR_PTR(-ENOMEM));
216         }
217         EXIT;
218  negative:
219         dentry->d_op = &ll_d_ops;
220         d_add(dentry, inode);
221         if (it->it_op == IT_LOOKUP)
222                 ll_intent_release(dentry);
223
224         return NULL;
225 }
226
227 static struct inode *ll_create_node(struct inode *dir, const char *name,
228                                     int namelen, const char *tgt, int tgtlen,
229                                     int mode, __u64 extra,
230                                     struct lookup_intent *it, 
231                                     struct lov_stripe_md *smd)
232 {
233         struct inode *inode;
234         struct ptlrpc_request *request = NULL;
235         struct mds_body *body;
236         int rc;
237         time_t time = CURRENT_TIME;
238         struct ll_sb_info *sbi = ll_i2sbi(dir);
239         int gid = current->fsgid;
240         struct ll_inode_md md;
241
242         ENTRY;
243
244         if (dir->i_mode & S_ISGID) {
245                 gid = dir->i_gid;
246                 if (S_ISDIR(mode))
247                         mode |= S_ISGID;
248         }
249
250         if (!it->it_disposition) {
251                 rc = mdc_create(&sbi->ll_mdc_conn, dir, name, namelen, tgt,
252                                  tgtlen, mode, current->fsuid,
253                                  gid, time, extra, smd, &request);
254                 if (rc) {
255                         inode = ERR_PTR(rc);
256                         GOTO(out, rc);
257                 }
258                 body = lustre_msg_buf(request->rq_repmsg, 0);
259                 md.md = smd;
260         } else {
261                 request = it->it_data;
262                 body = lustre_msg_buf(request->rq_repmsg, 1);
263                 md.md = NULL;
264         }
265
266         body->valid = OBD_MD_FLNOTOBD;
267
268         body->nlink = 1;
269         body->atime = body->ctime = body->mtime = time;
270         body->uid = current->fsuid;
271         body->gid = gid;
272         body->mode = mode;
273
274         md.body = body;
275
276         inode = iget4(dir->i_sb, body->ino, ll_find_inode, &md);
277         if (IS_ERR(inode)) {
278                 rc = PTR_ERR(inode);
279                 CERROR("new_inode -fatal: rc %d\n", rc);
280                 LBUG();
281                 GOTO(out, rc);
282         }
283
284         if (!list_empty(&inode->i_dentry)) {
285                 CERROR("new_inode -fatal: inode %d, ct %d lnk %d\n",
286                        body->ino, atomic_read(&inode->i_count),
287                        inode->i_nlink);
288                 iput(inode);
289                 LBUG();
290                 inode = ERR_PTR(-EIO);
291                 GOTO(out, -EIO);
292         }
293
294         EXIT;
295  out:
296         ptlrpc_free_req(request);
297         return inode;
298 }
299
300 int ll_mdc_unlink(struct inode *dir, struct inode *child,
301                   const char *name, int len)
302 {
303         struct ptlrpc_request *request = NULL;
304         int err;
305         struct ll_sb_info *sbi = ll_i2sbi(dir);
306
307         ENTRY;
308
309         err = mdc_unlink(&sbi->ll_mdc_conn, dir, child,
310                          name, len, &request);
311         ptlrpc_free_req(request);
312
313         RETURN(err);
314 }
315
316 int ll_mdc_link(struct dentry *src, struct inode *dir,
317                 const char *name, int len)
318 {
319         struct ptlrpc_request *request = NULL;
320         int err;
321         struct ll_sb_info *sbi = ll_i2sbi(dir);
322
323         ENTRY;
324
325         err = mdc_link(&sbi->ll_mdc_conn, src, dir, name,
326                        len, &request);
327         ptlrpc_free_req(request);
328
329         RETURN(err);
330 }
331
332 int ll_mdc_rename(struct inode *src, struct inode *tgt,
333                   struct dentry *old, struct dentry *new)
334 {
335         struct ptlrpc_request *request = NULL;
336         struct ll_sb_info *sbi = ll_i2sbi(src);
337         int err;
338
339         ENTRY;
340
341         err = mdc_rename(&sbi->ll_mdc_conn, src, tgt,
342                          old->d_name.name, old->d_name.len,
343                          new->d_name.name, new->d_name.len, &request);
344         ptlrpc_free_req(request);
345
346         RETURN(err);
347 }
348
349 /*
350  * By the time this is called, we already have created
351  * the directory cache entry for the new file, but it
352  * is so far negative - it has no inode.
353  *
354  * If the create succeeds, we fill in the inode information
355  * with d_instantiate().
356  */
357
358 static int ll_create(struct inode * dir, struct dentry * dentry, int mode)
359 {
360         int err, rc = 0;
361         struct obdo oa;
362         struct inode *inode;
363         struct lov_stripe_md *smd;
364         struct ll_inode_info *ii;
365
366         if (dentry->d_it->it_disposition == 0) {
367                 memset(&oa, 0, sizeof(oa));
368                 oa.o_valid = OBD_MD_FLMODE;
369                 oa.o_mode = S_IFREG | 0600;
370                 rc = obd_create(ll_i2obdconn(dir), &oa, &smd);
371                 if (rc)
372                         RETURN(rc);
373         }
374
375         mode = mode | S_IFREG;
376         CDEBUG(D_DENTRY, "name %s mode %o o_id %lld\n",
377                dentry->d_name.name, mode, (unsigned long long)oa.o_id);
378         inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
379                                NULL, 0, mode, 0, dentry->d_it, smd);
380
381         if (IS_ERR(inode)) {
382                 rc = PTR_ERR(inode);
383                 CERROR("error creating MDS object for id %Ld: rc = %d\n",
384                        (unsigned long long)oa.o_id, rc);
385                 GOTO(out_destroy, rc);
386         }
387
388         if (dentry->d_it->it_disposition) {
389                 struct ll_inode_info *ii = ll_i2info(inode);
390                 ii->lli_flags |= OBD_FL_CREATEONOPEN;
391                 memcpy(&ii->lli_intent_lock_handle,
392                        dentry->d_it->it_lock_handle,
393                        sizeof(struct lustre_handle));
394         }
395
396         /* no directory data updates when intents rule */
397         if (dentry->d_it->it_disposition == 0)
398                 rc = ext2_add_nondir(dentry, inode);
399         else
400                 d_instantiate(dentry, inode);
401         RETURN(rc);
402
403 out_destroy:
404         oa.o_easize = ii->lli_smd->lmd_size;
405         err = obd_destroy(ll_i2obdconn(dir), &oa, ii->lli_smd);
406         if (err)
407                 CERROR("error destroying object %Ld in error path: err = %d\n",
408                        (unsigned long long)oa.o_id, err);
409         return rc;
410 }
411
412 static int ll_mknod(struct inode *dir, struct dentry *dentry, int mode,
413                     int rdev)
414 {
415         struct inode * inode = ll_create_node(dir, dentry->d_name.name,
416                                               dentry->d_name.len, NULL, 0,
417                                               mode, rdev, NULL, NULL);
418         int err = PTR_ERR(inode);
419         if (!IS_ERR(inode))
420                 err = ext2_add_nondir(dentry, inode);
421         return err;
422 }
423
424 static int ll_symlink(struct inode *dir, struct dentry *dentry,
425                       const char *symname)
426 {
427         int err = -ENAMETOOLONG;
428         unsigned l = strlen(symname);
429         struct inode * inode;
430         struct ll_inode_info *oinfo;
431
432         inode = ll_create_node(dir, dentry->d_name.name,
433                                dentry->d_name.len, symname, l,
434                                S_IFLNK | S_IRWXUGO, 0, dentry->d_it, NULL);
435         err = PTR_ERR(inode);
436         if (IS_ERR(inode))
437                 return err;
438
439         oinfo = ll_i2info(inode);
440
441         OBD_ALLOC(oinfo->lli_symlink_name, l + 1);
442         memcpy(oinfo->lli_symlink_name, symname, l + 1);
443         inode->i_size = l;
444
445         err = ext2_add_nondir(dentry, inode);
446
447         if (err) {
448                 ext2_dec_count(inode);
449                 iput (inode);
450         }
451         return err;
452 }
453
454 static int ll_link(struct dentry * old_dentry, struct inode * dir,
455                    struct dentry *dentry)
456 {
457         int err;
458         struct inode *inode = old_dentry->d_inode;
459
460         if (S_ISDIR(inode->i_mode))
461                 return -EPERM;
462
463         if (inode->i_nlink >= EXT2_LINK_MAX)
464                 return -EMLINK;
465
466         err = ll_mdc_link(old_dentry, dir,
467                           dentry->d_name.name, dentry->d_name.len);
468         if (err) {
469                 EXIT;
470                 return err;
471         }
472
473         inode->i_ctime = CURRENT_TIME;
474         ext2_inc_count(inode);
475         atomic_inc(&inode->i_count);
476
477         return ext2_add_nondir(dentry, inode);
478 }
479
480 static int ll_mkdir(struct inode * dir, struct dentry * dentry, int mode)
481 {
482         struct inode * inode;
483         int err = -EMLINK;
484         ENTRY;
485
486         if (dir->i_nlink >= EXT2_LINK_MAX)
487                 goto out;
488
489         ext2_inc_count(dir);
490
491         inode = ll_create_node (dir, dentry->d_name.name,
492                                 dentry->d_name.len, NULL, 0,
493                                 S_IFDIR | mode, 0, dentry->d_it, NULL);
494         err = PTR_ERR(inode);
495         if (IS_ERR(inode))
496                 goto out_dir;
497
498         inode->i_nlink = 1;
499         ext2_inc_count(inode);
500
501         err = ext2_make_empty(inode, dir);
502         if (err)
503                 goto out_fail;
504
505         /* no directory data updates when intents rule */
506         if (dentry->d_it->it_disposition == 0) {
507                 err = ll_add_link(dentry, inode);
508                 if (err)
509                         goto out_fail;
510         }
511
512         d_instantiate(dentry, inode);
513 out:
514         EXIT;
515         return err;
516
517 out_fail:
518         ext2_dec_count(inode);
519         ext2_dec_count(inode);
520         iput(inode);
521         EXIT;
522 out_dir:
523         ext2_dec_count(dir);
524         EXIT;
525         goto out;
526 }
527
528 static int ll_unlink(struct inode * dir, struct dentry *dentry)
529 {
530         struct inode * inode = dentry->d_inode;
531         struct ext2_dir_entry_2 * de;
532         struct page * page;
533         int err = -ENOENT;
534
535         if (dentry->d_it && dentry->d_it->it_disposition) {
536                 inode->i_nlink = 0;
537                 GOTO(out, err = dentry->d_it->it_status);
538         }
539
540         de = ext2_find_entry (dir, dentry, &page);
541         if (!de)
542                 goto out;
543
544         err = ll_mdc_unlink(dir, dentry->d_inode,
545                             dentry->d_name.name, dentry->d_name.len);
546         if (err)
547                 goto out;
548
549         err = ext2_delete_entry (de, page);
550         if (err)
551                 goto out;
552
553         inode->i_ctime = dir->i_ctime;
554         ext2_dec_count(inode);
555 out:
556         return err;
557 }
558
559 static int ll_rmdir(struct inode * dir, struct dentry *dentry)
560 {
561         struct inode * inode = dentry->d_inode;
562         int err = 0;
563         int intent_did = dentry->d_it && dentry->d_it->it_disposition;
564
565         if (!intent_did) {
566                 if (!ext2_empty_dir(inode))
567                 LBUG();
568
569                 err = ll_unlink(dir, dentry);
570                 if (err)
571                         RETURN(err);
572         } else
573                 err = dentry->d_it->it_status;
574         inode->i_size = 0;
575         ext2_dec_count(inode);
576         ext2_dec_count(dir);
577         RETURN(err);
578 }
579
580 static int ll_rename(struct inode * old_dir, struct dentry * old_dentry,
581                      struct inode * new_dir, struct dentry * new_dentry)
582 {
583         struct inode * old_inode = old_dentry->d_inode;
584         struct inode * new_inode = new_dentry->d_inode;
585         struct page * dir_page = NULL;
586         struct ext2_dir_entry_2 * dir_de = NULL;
587         struct page * old_page;
588         struct ext2_dir_entry_2 * old_de;
589         int err = -ENOENT;
590
591         if (new_dentry->d_it && new_dentry->d_it->it_disposition)
592                 GOTO(out, err = new_dentry->d_it->it_status);
593
594         err = ll_mdc_rename(old_dir, new_dir, old_dentry, new_dentry);
595         if (err)
596                 goto out;
597
598         old_de = ext2_find_entry (old_dir, old_dentry, &old_page);
599         if (!old_de)
600                 goto out;
601
602         if (S_ISDIR(old_inode->i_mode)) {
603                 err = -EIO;
604                 dir_de = ext2_dotdot(old_inode, &dir_page);
605                 if (!dir_de)
606                         goto out_old;
607         }
608
609         if (new_inode) {
610                 struct page *new_page;
611                 struct ext2_dir_entry_2 *new_de;
612
613                 err = -ENOTEMPTY;
614                 if (dir_de && !ext2_empty_dir (new_inode))
615                         goto out_dir;
616
617                 err = -ENOENT;
618                 new_de = ext2_find_entry (new_dir, new_dentry, &new_page);
619                 if (!new_de)
620                         goto out_dir;
621                 ext2_inc_count(old_inode);
622                 ext2_set_link(new_dir, new_de, new_page, old_inode);
623                 new_inode->i_ctime = CURRENT_TIME;
624                 if (dir_de)
625                         new_inode->i_nlink--;
626                 ext2_dec_count(new_inode);
627         } else {
628                 if (dir_de) {
629                         err = -EMLINK;
630                         if (new_dir->i_nlink >= EXT2_LINK_MAX)
631                                 goto out_dir;
632                 }
633                 ext2_inc_count(old_inode);
634                 err = ll_add_link(new_dentry, old_inode);
635                 if (err) {
636                         ext2_dec_count(old_inode);
637                         goto out_dir;
638                 }
639                 if (dir_de)
640                         ext2_inc_count(new_dir);
641         }
642
643         ext2_delete_entry (old_de, old_page);
644         ext2_dec_count(old_inode);
645
646         if (dir_de) {
647                 ext2_set_link(old_inode, dir_de, dir_page, new_dir);
648                 ext2_dec_count(old_dir);
649         }
650         return 0;
651
652 out_dir:
653         if (dir_de) {
654                 kunmap(dir_page);
655                 page_cache_release(dir_page);
656         }
657 out_old:
658         kunmap(old_page);
659         page_cache_release(old_page);
660 out:
661         return err;
662 }
663
664 struct inode_operations ll_dir_inode_operations = {
665         create:         ll_create,
666         lookup2:        ll_lookup2,
667         link:           ll_link,
668         unlink:         ll_unlink,
669         symlink:        ll_symlink,
670         mkdir:          ll_mkdir,
671         rmdir:          ll_rmdir,
672         mknod:          ll_mknod,
673         rename:         ll_rename,
674         setattr:        ll_setattr
675 };