4
* Copyright (C) International Business Machines Corp., 2002,2010
5
* Author(s): Steve French (sfrench@us.ibm.com)
7
* This library is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU Lesser General Public License as published
9
* by the Free Software Foundation; either version 2.1 of the License, or
10
* (at your option) any later version.
12
* This library is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15
* the GNU Lesser General Public License for more details.
17
* You should have received a copy of the GNU Lesser General Public License
18
* along with this library; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
#include <linux/stat.h>
23
#include <linux/slab.h>
24
#include <linux/pagemap.h>
25
#include <asm/div64.h>
29
#include "cifsproto.h"
30
#include "cifs_debug.h"
31
#include "cifs_fs_sb.h"
35
static void cifs_set_ops(struct inode *inode)
37
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
39
switch (inode->i_mode & S_IFMT) {
41
inode->i_op = &cifs_file_inode_ops;
42
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
43
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
44
inode->i_fop = &cifs_file_direct_nobrl_ops;
46
inode->i_fop = &cifs_file_direct_ops;
47
} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
48
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49
inode->i_fop = &cifs_file_strict_nobrl_ops;
51
inode->i_fop = &cifs_file_strict_ops;
52
} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
53
inode->i_fop = &cifs_file_nobrl_ops;
54
else { /* not direct, send byte range locks */
55
inode->i_fop = &cifs_file_ops;
58
/* check if server can support readpages */
59
if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
60
PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
61
inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
63
inode->i_data.a_ops = &cifs_addr_ops;
66
#ifdef CONFIG_CIFS_DFS_UPCALL
67
if (IS_AUTOMOUNT(inode)) {
68
inode->i_op = &cifs_dfs_referral_inode_operations;
70
#else /* NO DFS support, treat as a directory */
73
inode->i_op = &cifs_dir_inode_ops;
74
inode->i_fop = &cifs_dir_ops;
78
inode->i_op = &cifs_symlink_inode_ops;
81
init_special_inode(inode, inode->i_mode, inode->i_rdev);
86
/* check inode attributes against fattr. If they don't match, tag the
87
* inode for cache invalidation
90
cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
92
struct cifsInodeInfo *cifs_i = CIFS_I(inode);
94
cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);
96
if (inode->i_state & I_NEW) {
97
cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);
101
/* don't bother with revalidation if we have an oplock */
102
if (cifs_i->clientCanCacheRead) {
103
cFYI(1, "%s: inode %llu is oplocked", __func__,
108
/* revalidate if mtime or size have changed */
109
if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
110
cifs_i->server_eof == fattr->cf_eof) {
111
cFYI(1, "%s: inode %llu is unchanged", __func__,
116
cFYI(1, "%s: invalidating inode %llu mapping", __func__,
118
cifs_i->invalid_mapping = true;
121
/* populate an inode with info from a cifs_fattr struct */
123
cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
125
struct cifsInodeInfo *cifs_i = CIFS_I(inode);
126
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
127
unsigned long oldtime = cifs_i->time;
129
cifs_revalidate_cache(inode, fattr);
131
inode->i_atime = fattr->cf_atime;
132
inode->i_mtime = fattr->cf_mtime;
133
inode->i_ctime = fattr->cf_ctime;
134
inode->i_rdev = fattr->cf_rdev;
135
set_nlink(inode, fattr->cf_nlink);
136
inode->i_uid = fattr->cf_uid;
137
inode->i_gid = fattr->cf_gid;
139
/* if dynperm is set, don't clobber existing mode */
140
if (inode->i_state & I_NEW ||
141
!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
142
inode->i_mode = fattr->cf_mode;
144
cifs_i->cifsAttrs = fattr->cf_cifsattrs;
146
if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
149
cifs_i->time = jiffies;
151
cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
152
oldtime, cifs_i->time);
154
cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
156
cifs_i->server_eof = fattr->cf_eof;
158
* Can't safely change the file size here if the client is writing to
159
* it due to potential races.
161
spin_lock(&inode->i_lock);
162
if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
163
i_size_write(inode, fattr->cf_eof);
166
* i_blocks is not related to (i_size / i_blksize),
167
* but instead 512 byte (2**9) size is required for
168
* calculating num blocks.
170
inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
172
spin_unlock(&inode->i_lock);
174
if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
175
inode->i_flags |= S_AUTOMOUNT;
180
cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
182
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
184
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
187
fattr->cf_uniqueid = iunique(sb, ROOT_I);
190
/* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
192
cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
193
struct cifs_sb_info *cifs_sb)
195
memset(fattr, 0, sizeof(*fattr));
196
fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
197
fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
198
fattr->cf_eof = le64_to_cpu(info->EndOfFile);
200
fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
201
fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
202
fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
203
fattr->cf_mode = le64_to_cpu(info->Permissions);
206
* Since we set the inode type below we need to mask off
207
* to avoid strange results if bits set above.
209
fattr->cf_mode &= ~S_IFMT;
210
switch (le32_to_cpu(info->Type)) {
212
fattr->cf_mode |= S_IFREG;
213
fattr->cf_dtype = DT_REG;
216
fattr->cf_mode |= S_IFLNK;
217
fattr->cf_dtype = DT_LNK;
220
fattr->cf_mode |= S_IFDIR;
221
fattr->cf_dtype = DT_DIR;
224
fattr->cf_mode |= S_IFCHR;
225
fattr->cf_dtype = DT_CHR;
226
fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
227
le64_to_cpu(info->DevMinor) & MINORMASK);
230
fattr->cf_mode |= S_IFBLK;
231
fattr->cf_dtype = DT_BLK;
232
fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
233
le64_to_cpu(info->DevMinor) & MINORMASK);
236
fattr->cf_mode |= S_IFIFO;
237
fattr->cf_dtype = DT_FIFO;
240
fattr->cf_mode |= S_IFSOCK;
241
fattr->cf_dtype = DT_SOCK;
244
/* safest to call it a file if we do not know */
245
fattr->cf_mode |= S_IFREG;
246
fattr->cf_dtype = DT_REG;
247
cFYI(1, "unknown type %d", le32_to_cpu(info->Type));
251
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
252
fattr->cf_uid = cifs_sb->mnt_uid;
254
fattr->cf_uid = le64_to_cpu(info->Uid);
256
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
257
fattr->cf_gid = cifs_sb->mnt_gid;
259
fattr->cf_gid = le64_to_cpu(info->Gid);
261
fattr->cf_nlink = le64_to_cpu(info->Nlinks);
265
* Fill a cifs_fattr struct with fake inode info.
267
* Needed to setup cifs_fattr data for the directory which is the
268
* junction to the new submount (ie to setup the fake directory
269
* which represents a DFS referral).
272
cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
274
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
276
cFYI(1, "creating fake fattr for DFS referral");
278
memset(fattr, 0, sizeof(*fattr));
279
fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
280
fattr->cf_uid = cifs_sb->mnt_uid;
281
fattr->cf_gid = cifs_sb->mnt_gid;
282
fattr->cf_atime = CURRENT_TIME;
283
fattr->cf_ctime = CURRENT_TIME;
284
fattr->cf_mtime = CURRENT_TIME;
286
fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
289
int cifs_get_file_info_unix(struct file *filp)
293
FILE_UNIX_BASIC_INFO find_data;
294
struct cifs_fattr fattr;
295
struct inode *inode = filp->f_path.dentry->d_inode;
296
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
297
struct cifsFileInfo *cfile = filp->private_data;
298
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
301
rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
303
cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
304
} else if (rc == -EREMOTE) {
305
cifs_create_dfs_fattr(&fattr, inode->i_sb);
309
cifs_fattr_to_inode(inode, &fattr);
314
int cifs_get_inode_info_unix(struct inode **pinode,
315
const unsigned char *full_path,
316
struct super_block *sb, int xid)
319
FILE_UNIX_BASIC_INFO find_data;
320
struct cifs_fattr fattr;
321
struct cifs_tcon *tcon;
322
struct tcon_link *tlink;
323
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
325
cFYI(1, "Getting info on %s", full_path);
327
tlink = cifs_sb_tlink(cifs_sb);
329
return PTR_ERR(tlink);
330
tcon = tlink_tcon(tlink);
332
/* could have done a find first instead but this returns more info */
333
rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
334
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
335
CIFS_MOUNT_MAP_SPECIAL_CHR);
336
cifs_put_tlink(tlink);
339
cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
340
} else if (rc == -EREMOTE) {
341
cifs_create_dfs_fattr(&fattr, sb);
347
/* check for Minshall+French symlinks */
348
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
349
int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
351
cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
354
if (*pinode == NULL) {
356
cifs_fill_uniqueid(sb, &fattr);
357
*pinode = cifs_iget(sb, &fattr);
361
/* we already have inode, update it */
362
cifs_fattr_to_inode(*pinode, &fattr);
369
cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
370
struct cifs_sb_info *cifs_sb, int xid)
375
struct tcon_link *tlink;
376
struct cifs_tcon *tcon;
377
struct cifs_io_parms io_parms;
379
unsigned int bytes_read;
384
fattr->cf_mode &= ~S_IFMT;
386
if (fattr->cf_eof == 0) {
387
fattr->cf_mode |= S_IFIFO;
388
fattr->cf_dtype = DT_FIFO;
390
} else if (fattr->cf_eof < 8) {
391
fattr->cf_mode |= S_IFREG;
392
fattr->cf_dtype = DT_REG;
393
return -EINVAL; /* EOPNOTSUPP? */
396
tlink = cifs_sb_tlink(cifs_sb);
398
return PTR_ERR(tlink);
399
tcon = tlink_tcon(tlink);
401
rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
402
CREATE_NOT_DIR, &netfid, &oplock, NULL,
404
cifs_sb->mnt_cifs_flags &
405
CIFS_MOUNT_MAP_SPECIAL_CHR);
407
int buf_type = CIFS_NO_BUFFER;
409
io_parms.netfid = netfid;
410
io_parms.pid = current->tgid;
411
io_parms.tcon = tcon;
413
io_parms.length = 24;
414
rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
416
if ((rc == 0) && (bytes_read >= 8)) {
417
if (memcmp("IntxBLK", pbuf, 8) == 0) {
418
cFYI(1, "Block device");
419
fattr->cf_mode |= S_IFBLK;
420
fattr->cf_dtype = DT_BLK;
421
if (bytes_read == 24) {
422
/* we have enough to decode dev num */
423
__u64 mjr; /* major */
424
__u64 mnr; /* minor */
425
mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
426
mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
427
fattr->cf_rdev = MKDEV(mjr, mnr);
429
} else if (memcmp("IntxCHR", pbuf, 8) == 0) {
430
cFYI(1, "Char device");
431
fattr->cf_mode |= S_IFCHR;
432
fattr->cf_dtype = DT_CHR;
433
if (bytes_read == 24) {
434
/* we have enough to decode dev num */
435
__u64 mjr; /* major */
436
__u64 mnr; /* minor */
437
mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
438
mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
439
fattr->cf_rdev = MKDEV(mjr, mnr);
441
} else if (memcmp("IntxLNK", pbuf, 7) == 0) {
443
fattr->cf_mode |= S_IFLNK;
444
fattr->cf_dtype = DT_LNK;
446
fattr->cf_mode |= S_IFREG; /* file? */
447
fattr->cf_dtype = DT_REG;
451
fattr->cf_mode |= S_IFREG; /* then it is a file */
452
fattr->cf_dtype = DT_REG;
453
rc = -EOPNOTSUPP; /* or some unknown SFU type */
455
CIFSSMBClose(xid, tcon, netfid);
457
cifs_put_tlink(tlink);
461
#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
464
* Fetch mode bits as provided by SFU.
466
* FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
468
static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
469
struct cifs_sb_info *cifs_sb, int xid)
471
#ifdef CONFIG_CIFS_XATTR
475
struct tcon_link *tlink;
476
struct cifs_tcon *tcon;
478
tlink = cifs_sb_tlink(cifs_sb);
480
return PTR_ERR(tlink);
481
tcon = tlink_tcon(tlink);
483
rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",
484
ea_value, 4 /* size of buf */, cifs_sb->local_nls,
485
cifs_sb->mnt_cifs_flags &
486
CIFS_MOUNT_MAP_SPECIAL_CHR);
487
cifs_put_tlink(tlink);
491
mode = le32_to_cpu(*((__le32 *)ea_value));
492
fattr->cf_mode &= ~SFBITS_MASK;
493
cFYI(1, "special bits 0%o org mode 0%o", mode,
495
fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
496
cFYI(1, "special mode bits 0%o", mode);
505
/* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
507
cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
508
struct cifs_sb_info *cifs_sb, bool adjust_tz)
510
struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
512
memset(fattr, 0, sizeof(*fattr));
513
fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
514
if (info->DeletePending)
515
fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
517
if (info->LastAccessTime)
518
fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
520
fattr->cf_atime = CURRENT_TIME;
522
fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
523
fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
526
fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
527
fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
530
fattr->cf_eof = le64_to_cpu(info->EndOfFile);
531
fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
532
fattr->cf_createtime = le64_to_cpu(info->CreationTime);
534
if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
535
fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
536
fattr->cf_dtype = DT_DIR;
538
fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
539
fattr->cf_dtype = DT_REG;
541
/* clear write bits if ATTR_READONLY is set */
542
if (fattr->cf_cifsattrs & ATTR_READONLY)
543
fattr->cf_mode &= ~(S_IWUGO);
546
fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
548
fattr->cf_uid = cifs_sb->mnt_uid;
549
fattr->cf_gid = cifs_sb->mnt_gid;
552
int cifs_get_file_info(struct file *filp)
556
FILE_ALL_INFO find_data;
557
struct cifs_fattr fattr;
558
struct inode *inode = filp->f_path.dentry->d_inode;
559
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
560
struct cifsFileInfo *cfile = filp->private_data;
561
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
564
rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);
567
cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
570
cifs_create_dfs_fattr(&fattr, inode->i_sb);
576
* FIXME: legacy server -- fall back to path-based call?
577
* for now, just skip revalidating and mark inode for
581
CIFS_I(inode)->time = 0;
587
* don't bother with SFU junk here -- just mark inode as needing
590
fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
591
fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
592
cifs_fattr_to_inode(inode, &fattr);
598
int cifs_get_inode_info(struct inode **pinode,
599
const unsigned char *full_path, FILE_ALL_INFO *pfindData,
600
struct super_block *sb, int xid, const __u16 *pfid)
603
struct cifs_tcon *pTcon;
604
struct tcon_link *tlink;
605
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
607
bool adjustTZ = false;
608
struct cifs_fattr fattr;
610
tlink = cifs_sb_tlink(cifs_sb);
612
return PTR_ERR(tlink);
613
pTcon = tlink_tcon(tlink);
615
cFYI(1, "Getting info on %s", full_path);
617
if ((pfindData == NULL) && (*pinode != NULL)) {
618
if (CIFS_I(*pinode)->clientCanCacheRead) {
619
cFYI(1, "No need to revalidate cached inode sizes");
624
/* if file info not passed in then get it from server */
625
if (pfindData == NULL) {
626
buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
631
pfindData = (FILE_ALL_INFO *)buf;
633
/* could do find first instead but this returns more info */
634
rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
636
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
637
CIFS_MOUNT_MAP_SPECIAL_CHR);
638
/* BB optimize code so we do not make the above call
639
when server claims no NT SMB support and the above call
640
failed at least once - set flag in tcon or mount */
641
if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
642
rc = SMBQueryInformation(xid, pTcon, full_path,
643
pfindData, cifs_sb->local_nls,
644
cifs_sb->mnt_cifs_flags &
645
CIFS_MOUNT_MAP_SPECIAL_CHR);
651
cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
653
} else if (rc == -EREMOTE) {
654
cifs_create_dfs_fattr(&fattr, sb);
661
* If an inode wasn't passed in, then get the inode number
663
* Is an i_ino of zero legal? Can we use that to check if the server
664
* supports returning inode numbers? Are there other sanity checks we
665
* can use to ensure that the server is really filling in that field?
667
* We can not use the IndexNumber field by default from Windows or
668
* Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
669
* CIFS spec claims that this value is unique within the scope of a
670
* share, and the windows docs hint that it's actually unique
673
* There may be higher info levels that work but are there Windows
674
* server or network appliances for which IndexNumber field is not
677
if (*pinode == NULL) {
678
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
681
rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
682
full_path, &fattr.cf_uniqueid,
684
cifs_sb->mnt_cifs_flags &
685
CIFS_MOUNT_MAP_SPECIAL_CHR);
686
if (rc1 || !fattr.cf_uniqueid) {
687
cFYI(1, "GetSrvInodeNum rc %d", rc1);
688
fattr.cf_uniqueid = iunique(sb, ROOT_I);
689
cifs_autodisable_serverino(cifs_sb);
692
fattr.cf_uniqueid = iunique(sb, ROOT_I);
695
fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;
698
/* query for SFU type info if supported and needed */
699
if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
700
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
701
tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
703
cFYI(1, "cifs_sfu_type failed: %d", tmprc);
706
#ifdef CONFIG_CIFS_ACL
707
/* fill in 0777 bits from ACL */
708
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
709
rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
712
cFYI(1, "%s: Getting ACL failed with error: %d",
717
#endif /* CONFIG_CIFS_ACL */
719
/* fill in remaining high mode bits e.g. SUID, VTX */
720
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
721
cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
723
/* check for Minshall+French symlinks */
724
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
725
tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
727
cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
731
*pinode = cifs_iget(sb, &fattr);
735
cifs_fattr_to_inode(*pinode, &fattr);
740
cifs_put_tlink(tlink);
744
static const struct inode_operations cifs_ipc_inode_ops = {
745
.lookup = cifs_lookup,
748
char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
749
struct cifs_tcon *tcon)
751
int pplen = vol->prepath ? strlen(vol->prepath) : 0;
753
char *full_path = NULL;
755
/* if no prefix path, simply set path to the root of share to "" */
757
full_path = kmalloc(1, GFP_KERNEL);
763
if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
764
dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
768
full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
769
if (full_path == NULL)
773
strncpy(full_path, tcon->treeName, dfsplen);
774
strncpy(full_path + dfsplen, vol->prepath, pplen);
775
convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
776
full_path[dfsplen + pplen] = 0; /* add trailing null */
781
cifs_find_inode(struct inode *inode, void *opaque)
783
struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
785
/* don't match inode with different uniqueid */
786
if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
789
/* use createtime like an i_generation field */
790
if (CIFS_I(inode)->createtime != fattr->cf_createtime)
793
/* don't match inode of different type */
794
if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
797
/* if it's not a directory or has no dentries, then flag it */
798
if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
799
fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
805
cifs_init_inode(struct inode *inode, void *opaque)
807
struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
809
CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
810
CIFS_I(inode)->createtime = fattr->cf_createtime;
815
* walk dentry list for an inode and report whether it has aliases that
816
* are hashed. We use this to determine if a directory inode can actually
820
inode_has_hashed_dentries(struct inode *inode)
822
struct dentry *dentry;
824
spin_lock(&inode->i_lock);
825
list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
826
if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
827
spin_unlock(&inode->i_lock);
831
spin_unlock(&inode->i_lock);
835
/* Given fattrs, get a corresponding inode */
837
cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
843
cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);
845
/* hash down to 32-bits on 32-bit arch */
846
hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
848
inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
850
/* was there a potentially problematic inode collision? */
851
if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
852
fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
854
if (inode_has_hashed_dentries(inode)) {
855
cifs_autodisable_serverino(CIFS_SB(sb));
857
fattr->cf_uniqueid = iunique(sb, ROOT_I);
858
goto retry_iget5_locked;
862
cifs_fattr_to_inode(inode, fattr);
863
if (sb->s_flags & MS_NOATIME)
864
inode->i_flags |= S_NOATIME | S_NOCMTIME;
865
if (inode->i_state & I_NEW) {
867
if (S_ISREG(inode->i_mode))
868
inode->i_data.backing_dev_info = sb->s_bdi;
869
#ifdef CONFIG_CIFS_FSCACHE
870
/* initialize per-inode cache cookie pointer */
871
CIFS_I(inode)->fscache = NULL;
873
unlock_new_inode(inode);
880
/* gets root inode */
881
struct inode *cifs_root_iget(struct super_block *sb)
884
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
885
struct inode *inode = NULL;
887
struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
891
rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
893
rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
900
#ifdef CONFIG_CIFS_FSCACHE
901
/* populate tcon->resource_id */
902
tcon->resource_id = CIFS_I(inode)->uniqueid;
905
if (rc && tcon->ipc) {
906
cFYI(1, "ipc connection - fake read inode");
907
inode->i_mode |= S_IFDIR;
909
inode->i_op = &cifs_ipc_inode_ops;
910
inode->i_fop = &simple_dir_operations;
911
inode->i_uid = cifs_sb->mnt_uid;
912
inode->i_gid = cifs_sb->mnt_gid;
919
/* can not call macro FreeXid here since in a void func
920
* TODO: This is no longer true
927
cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
928
char *full_path, __u32 dosattr)
934
bool set_time = false;
935
struct cifsFileInfo *open_file;
936
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
937
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
938
struct tcon_link *tlink = NULL;
939
struct cifs_tcon *pTcon;
940
FILE_BASIC_INFO info_buf;
945
if (attrs->ia_valid & ATTR_ATIME) {
947
info_buf.LastAccessTime =
948
cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
950
info_buf.LastAccessTime = 0;
952
if (attrs->ia_valid & ATTR_MTIME) {
954
info_buf.LastWriteTime =
955
cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
957
info_buf.LastWriteTime = 0;
960
* Samba throws this field away, but windows may actually use it.
961
* Do not set ctime unless other time stamps are changed explicitly
962
* (i.e. by utimes()) since we would then have a mix of client and
965
if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
966
cFYI(1, "CIFS - CTIME changed");
967
info_buf.ChangeTime =
968
cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
970
info_buf.ChangeTime = 0;
972
info_buf.CreationTime = 0; /* don't change */
973
info_buf.Attributes = cpu_to_le32(dosattr);
976
* If the file is already open for write, just use that fileid
978
open_file = find_writable_file(cifsInode, true);
980
netfid = open_file->netfid;
981
netpid = open_file->pid;
982
pTcon = tlink_tcon(open_file->tlink);
983
goto set_via_filehandle;
986
tlink = cifs_sb_tlink(cifs_sb);
992
pTcon = tlink_tcon(tlink);
995
* NT4 apparently returns success on this call, but it doesn't
998
if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
999
rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
1000
&info_buf, cifs_sb->local_nls,
1001
cifs_sb->mnt_cifs_flags &
1002
CIFS_MOUNT_MAP_SPECIAL_CHR);
1004
cifsInode->cifsAttrs = dosattr;
1006
} else if (rc != -EOPNOTSUPP && rc != -EINVAL)
1010
cFYI(1, "calling SetFileInfo since SetPathInfo for "
1011
"times not supported by this server");
1012
rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1013
SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1014
CREATE_NOT_DIR, &netfid, &oplock,
1015
NULL, cifs_sb->local_nls,
1016
cifs_sb->mnt_cifs_flags &
1017
CIFS_MOUNT_MAP_SPECIAL_CHR);
1025
netpid = current->tgid;
1028
rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
1030
cifsInode->cifsAttrs = dosattr;
1032
if (open_file == NULL)
1033
CIFSSMBClose(xid, pTcon, netfid);
1035
cifsFileInfo_put(open_file);
1038
cifs_put_tlink(tlink);
1043
* open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1044
* and rename it to a random name that hopefully won't conflict with
1048
cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
1053
struct inode *inode = dentry->d_inode;
1054
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1055
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1056
struct tcon_link *tlink;
1057
struct cifs_tcon *tcon;
1058
__u32 dosattr, origattr;
1059
FILE_BASIC_INFO *info_buf = NULL;
1061
tlink = cifs_sb_tlink(cifs_sb);
1063
return PTR_ERR(tlink);
1064
tcon = tlink_tcon(tlink);
1066
rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1067
DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1068
&netfid, &oplock, NULL, cifs_sb->local_nls,
1069
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1073
origattr = cifsInode->cifsAttrs;
1075
origattr |= ATTR_NORMAL;
1077
dosattr = origattr & ~ATTR_READONLY;
1079
dosattr |= ATTR_NORMAL;
1080
dosattr |= ATTR_HIDDEN;
1082
/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1083
if (dosattr != origattr) {
1084
info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1085
if (info_buf == NULL) {
1089
info_buf->Attributes = cpu_to_le32(dosattr);
1090
rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1092
/* although we would like to mark the file hidden
1093
if that fails we will still try to rename it */
1095
cifsInode->cifsAttrs = dosattr;
1097
dosattr = origattr; /* since not able to change them */
1100
/* rename the file */
1101
rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1102
cifs_sb->mnt_cifs_flags &
1103
CIFS_MOUNT_MAP_SPECIAL_CHR);
1109
/* try to set DELETE_ON_CLOSE */
1110
if (!cifsInode->delete_pending) {
1111
rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1114
* some samba versions return -ENOENT when we try to set the
1115
* file disposition here. Likely a samba bug, but work around
1116
* it for now. This means that some cifsXXX files may hang
1117
* around after they shouldn't.
1119
* BB: remove this hack after more servers have the fix
1127
cifsInode->delete_pending = true;
1131
CIFSSMBClose(xid, tcon, netfid);
1134
cifs_put_tlink(tlink);
1138
* reset everything back to the original state. Don't bother
1139
* dealing with errors here since we can't do anything about
1143
CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1144
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1145
CIFS_MOUNT_MAP_SPECIAL_CHR);
1147
if (dosattr != origattr) {
1148
info_buf->Attributes = cpu_to_le32(origattr);
1149
if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1151
cifsInode->cifsAttrs = origattr;
1159
* If dentry->d_inode is null (usually meaning the cached dentry
1160
* is a negative dentry) then we would attempt a standard SMB delete, but
1161
* if that fails we can not attempt the fall back mechanisms on EACCESS
1162
* but will return the EACCESS to the caller. Note that the VFS does not call
1163
* unlink on negative dentries currently.
1165
int cifs_unlink(struct inode *dir, struct dentry *dentry)
1169
char *full_path = NULL;
1170
struct inode *inode = dentry->d_inode;
1171
struct cifsInodeInfo *cifs_inode;
1172
struct super_block *sb = dir->i_sb;
1173
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1174
struct tcon_link *tlink;
1175
struct cifs_tcon *tcon;
1176
struct iattr *attrs = NULL;
1177
__u32 dosattr = 0, origattr = 0;
1179
cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);
1181
tlink = cifs_sb_tlink(cifs_sb);
1183
return PTR_ERR(tlink);
1184
tcon = tlink_tcon(tlink);
1188
/* Unlink can be called from rename so we can not take the
1189
* sb->s_vfs_rename_mutex here */
1190
full_path = build_path_from_dentry(dentry);
1191
if (full_path == NULL) {
1196
if ((tcon->ses->capabilities & CAP_UNIX) &&
1197
(CIFS_UNIX_POSIX_PATH_OPS_CAP &
1198
le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1199
rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1200
SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1201
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1202
cFYI(1, "posix del rc %d", rc);
1203
if ((rc == 0) || (rc == -ENOENT))
1204
goto psx_del_no_retry;
1208
rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
1209
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1215
} else if (rc == -ENOENT) {
1217
} else if (rc == -ETXTBSY) {
1218
rc = cifs_rename_pending_delete(full_path, dentry, xid);
1221
} else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1222
attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1223
if (attrs == NULL) {
1228
/* try to reset dos attributes */
1229
cifs_inode = CIFS_I(inode);
1230
origattr = cifs_inode->cifsAttrs;
1232
origattr |= ATTR_NORMAL;
1233
dosattr = origattr & ~ATTR_READONLY;
1235
dosattr |= ATTR_NORMAL;
1236
dosattr |= ATTR_HIDDEN;
1238
rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1242
goto retry_std_delete;
1245
/* undo the setattr if we errored out and it's needed */
1246
if (rc != 0 && dosattr != 0)
1247
cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1251
cifs_inode = CIFS_I(inode);
1252
cifs_inode->time = 0; /* will force revalidate to get info
1254
inode->i_ctime = current_fs_time(sb);
1256
dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1257
cifs_inode = CIFS_I(dir);
1258
CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1263
cifs_put_tlink(tlink);
1267
int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1271
struct cifs_sb_info *cifs_sb;
1272
struct tcon_link *tlink;
1273
struct cifs_tcon *pTcon;
1274
char *full_path = NULL;
1275
struct inode *newinode = NULL;
1276
struct cifs_fattr fattr;
1278
cFYI(1, "In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode);
1280
cifs_sb = CIFS_SB(inode->i_sb);
1281
tlink = cifs_sb_tlink(cifs_sb);
1283
return PTR_ERR(tlink);
1284
pTcon = tlink_tcon(tlink);
1288
full_path = build_path_from_dentry(direntry);
1289
if (full_path == NULL) {
1294
if ((pTcon->ses->capabilities & CAP_UNIX) &&
1295
(CIFS_UNIX_POSIX_PATH_OPS_CAP &
1296
le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1298
FILE_UNIX_BASIC_INFO *pInfo =
1299
kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1300
if (pInfo == NULL) {
1305
mode &= ~current_umask();
1306
rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1307
mode, NULL /* netfid */, pInfo, &oplock,
1308
full_path, cifs_sb->local_nls,
1309
cifs_sb->mnt_cifs_flags &
1310
CIFS_MOUNT_MAP_SPECIAL_CHR);
1311
if (rc == -EOPNOTSUPP) {
1313
goto mkdir_retry_old;
1315
cFYI(1, "posix mkdir returned 0x%x", rc);
1318
if (pInfo->Type == cpu_to_le32(-1)) {
1319
/* no return info, go query for it */
1321
goto mkdir_get_info;
1323
/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1327
cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1328
cifs_fill_uniqueid(inode->i_sb, &fattr);
1329
newinode = cifs_iget(inode->i_sb, &fattr);
1332
goto mkdir_get_info;
1335
d_instantiate(direntry, newinode);
1337
#ifdef CONFIG_CIFS_DEBUG2
1338
cFYI(1, "instantiated dentry %p %s to inode %p",
1339
direntry, direntry->d_name.name, newinode);
1341
if (newinode->i_nlink != 2)
1342
cFYI(1, "unexpected number of links %d",
1350
/* BB add setting the equivalent of mode via CreateX w/ACLs */
1351
rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1352
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1354
cFYI(1, "cifs_mkdir returned 0x%x", rc);
1359
if (pTcon->unix_ext)
1360
rc = cifs_get_inode_info_unix(&newinode, full_path,
1363
rc = cifs_get_inode_info(&newinode, full_path, NULL,
1364
inode->i_sb, xid, NULL);
1366
d_instantiate(direntry, newinode);
1367
/* setting nlink not necessary except in cases where we
1368
* failed to get it from the server or was set bogus */
1369
if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1370
set_nlink(direntry->d_inode, 2);
1372
mode &= ~current_umask();
1373
/* must turn on setgid bit if parent dir has it */
1374
if (inode->i_mode & S_ISGID)
1377
if (pTcon->unix_ext) {
1378
struct cifs_unix_set_info_args args = {
1380
.ctime = NO_CHANGE_64,
1381
.atime = NO_CHANGE_64,
1382
.mtime = NO_CHANGE_64,
1385
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1386
args.uid = (__u64)current_fsuid();
1387
if (inode->i_mode & S_ISGID)
1388
args.gid = (__u64)inode->i_gid;
1390
args.gid = (__u64)current_fsgid();
1392
args.uid = NO_CHANGE_64;
1393
args.gid = NO_CHANGE_64;
1395
CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1397
cifs_sb->mnt_cifs_flags &
1398
CIFS_MOUNT_MAP_SPECIAL_CHR);
1400
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1401
(mode & S_IWUGO) == 0) {
1402
FILE_BASIC_INFO pInfo;
1403
struct cifsInodeInfo *cifsInode;
1406
memset(&pInfo, 0, sizeof(pInfo));
1407
cifsInode = CIFS_I(newinode);
1408
dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1409
pInfo.Attributes = cpu_to_le32(dosattrs);
1410
tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1413
cifs_sb->mnt_cifs_flags &
1414
CIFS_MOUNT_MAP_SPECIAL_CHR);
1416
cifsInode->cifsAttrs = dosattrs;
1418
if (direntry->d_inode) {
1419
if (cifs_sb->mnt_cifs_flags &
1421
direntry->d_inode->i_mode =
1424
if (cifs_sb->mnt_cifs_flags &
1425
CIFS_MOUNT_SET_UID) {
1426
direntry->d_inode->i_uid =
1428
if (inode->i_mode & S_ISGID)
1429
direntry->d_inode->i_gid =
1432
direntry->d_inode->i_gid =
1441
cifs_put_tlink(tlink);
1445
int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1449
struct cifs_sb_info *cifs_sb;
1450
struct tcon_link *tlink;
1451
struct cifs_tcon *pTcon;
1452
char *full_path = NULL;
1453
struct cifsInodeInfo *cifsInode;
1455
cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1459
full_path = build_path_from_dentry(direntry);
1460
if (full_path == NULL) {
1465
cifs_sb = CIFS_SB(inode->i_sb);
1466
tlink = cifs_sb_tlink(cifs_sb);
1467
if (IS_ERR(tlink)) {
1468
rc = PTR_ERR(tlink);
1471
pTcon = tlink_tcon(tlink);
1473
rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1474
cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1475
cifs_put_tlink(tlink);
1479
spin_lock(&direntry->d_inode->i_lock);
1480
i_size_write(direntry->d_inode, 0);
1481
clear_nlink(direntry->d_inode);
1482
spin_unlock(&direntry->d_inode->i_lock);
1485
cifsInode = CIFS_I(direntry->d_inode);
1486
cifsInode->time = 0; /* force revalidate to go get info when
1489
cifsInode = CIFS_I(inode);
1490
cifsInode->time = 0; /* force revalidate to get parent dir info
1491
since cached search results now invalid */
1493
direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1494
current_fs_time(inode->i_sb);
1503
cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1504
struct dentry *to_dentry, const char *toPath)
1506
struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1507
struct tcon_link *tlink;
1508
struct cifs_tcon *pTcon;
1512
tlink = cifs_sb_tlink(cifs_sb);
1514
return PTR_ERR(tlink);
1515
pTcon = tlink_tcon(tlink);
1517
/* try path-based rename first */
1518
rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1519
cifs_sb->mnt_cifs_flags &
1520
CIFS_MOUNT_MAP_SPECIAL_CHR);
1523
* don't bother with rename by filehandle unless file is busy and
1524
* source Note that cross directory moves do not work with
1525
* rename by filehandle to various Windows servers.
1527
if (rc == 0 || rc != -ETXTBSY)
1528
goto do_rename_exit;
1530
/* open-file renames don't work across directories */
1531
if (to_dentry->d_parent != from_dentry->d_parent)
1532
goto do_rename_exit;
1534
/* open the file to be renamed -- we need DELETE perms */
1535
rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1536
CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1537
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1538
CIFS_MOUNT_MAP_SPECIAL_CHR);
1541
rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1542
(const char *) to_dentry->d_name.name,
1543
cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1544
CIFS_MOUNT_MAP_SPECIAL_CHR);
1546
CIFSSMBClose(xid, pTcon, srcfid);
1549
cifs_put_tlink(tlink);
1553
int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1554
struct inode *target_dir, struct dentry *target_dentry)
1556
char *fromName = NULL;
1557
char *toName = NULL;
1558
struct cifs_sb_info *cifs_sb;
1559
struct tcon_link *tlink;
1560
struct cifs_tcon *tcon;
1561
FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1562
FILE_UNIX_BASIC_INFO *info_buf_target;
1565
cifs_sb = CIFS_SB(source_dir->i_sb);
1566
tlink = cifs_sb_tlink(cifs_sb);
1568
return PTR_ERR(tlink);
1569
tcon = tlink_tcon(tlink);
1574
* we already have the rename sem so we do not need to
1575
* grab it again here to protect the path integrity
1577
fromName = build_path_from_dentry(source_dentry);
1578
if (fromName == NULL) {
1580
goto cifs_rename_exit;
1583
toName = build_path_from_dentry(target_dentry);
1584
if (toName == NULL) {
1586
goto cifs_rename_exit;
1589
rc = cifs_do_rename(xid, source_dentry, fromName,
1590
target_dentry, toName);
1592
if (rc == -EEXIST && tcon->unix_ext) {
1594
* Are src and dst hardlinks of same inode? We can
1595
* only tell with unix extensions enabled
1598
kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1600
if (info_buf_source == NULL) {
1602
goto cifs_rename_exit;
1605
info_buf_target = info_buf_source + 1;
1606
tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1609
cifs_sb->mnt_cifs_flags &
1610
CIFS_MOUNT_MAP_SPECIAL_CHR);
1614
tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1617
cifs_sb->mnt_cifs_flags &
1618
CIFS_MOUNT_MAP_SPECIAL_CHR);
1620
if (tmprc == 0 && (info_buf_source->UniqueId ==
1621
info_buf_target->UniqueId)) {
1622
/* same file, POSIX says that this is a noop */
1624
goto cifs_rename_exit;
1626
} /* else ... BB we could add the same check for Windows by
1627
checking the UniqueId via FILE_INTERNAL_INFO */
1630
/* Try unlinking the target dentry if it's not negative */
1631
if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1632
tmprc = cifs_unlink(target_dir, target_dentry);
1634
goto cifs_rename_exit;
1636
rc = cifs_do_rename(xid, source_dentry, fromName,
1637
target_dentry, toName);
1641
kfree(info_buf_source);
1645
cifs_put_tlink(tlink);
1650
cifs_inode_needs_reval(struct inode *inode)
1652
struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1653
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1655
if (cifs_i->clientCanCacheRead)
1658
if (!lookupCacheEnabled)
1661
if (cifs_i->time == 0)
1664
if (!time_in_range(jiffies, cifs_i->time,
1665
cifs_i->time + cifs_sb->actimeo))
1668
/* hardlinked files w/ noserverino get "special" treatment */
1669
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1670
S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1677
* Zap the cache. Called when invalid_mapping flag is set.
1680
cifs_invalidate_mapping(struct inode *inode)
1683
struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1685
cifs_i->invalid_mapping = false;
1687
if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1688
rc = invalidate_inode_pages2(inode->i_mapping);
1690
cERROR(1, "%s: could not invalidate inode %p", __func__,
1692
cifs_i->invalid_mapping = true;
1696
cifs_fscache_reset_inode_cookie(inode);
1700
int cifs_revalidate_file_attr(struct file *filp)
1703
struct inode *inode = filp->f_path.dentry->d_inode;
1704
struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1706
if (!cifs_inode_needs_reval(inode))
1709
if (tlink_tcon(cfile->tlink)->unix_ext)
1710
rc = cifs_get_file_info_unix(filp);
1712
rc = cifs_get_file_info(filp);
1717
int cifs_revalidate_dentry_attr(struct dentry *dentry)
1721
struct inode *inode = dentry->d_inode;
1722
struct super_block *sb = dentry->d_sb;
1723
char *full_path = NULL;
1728
if (!cifs_inode_needs_reval(inode))
1733
/* can not safely grab the rename sem here if rename calls revalidate
1734
since that would deadlock */
1735
full_path = build_path_from_dentry(dentry);
1736
if (full_path == NULL) {
1741
cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1742
"%ld jiffies %ld", full_path, inode, inode->i_count.counter,
1743
dentry, dentry->d_time, jiffies);
1745
if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1746
rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1748
rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1757
int cifs_revalidate_file(struct file *filp)
1760
struct inode *inode = filp->f_path.dentry->d_inode;
1762
rc = cifs_revalidate_file_attr(filp);
1766
if (CIFS_I(inode)->invalid_mapping)
1767
rc = cifs_invalidate_mapping(inode);
1771
/* revalidate a dentry's inode attributes */
1772
int cifs_revalidate_dentry(struct dentry *dentry)
1775
struct inode *inode = dentry->d_inode;
1777
rc = cifs_revalidate_dentry_attr(dentry);
1781
if (CIFS_I(inode)->invalid_mapping)
1782
rc = cifs_invalidate_mapping(inode);
1786
int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1789
struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1790
struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1791
struct inode *inode = dentry->d_inode;
1795
* We need to be sure that all dirty pages are written and the server
1796
* has actual ctime, mtime and file length.
1798
if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1799
inode->i_mapping->nrpages != 0) {
1800
rc = filemap_fdatawait(inode->i_mapping);
1802
mapping_set_error(inode->i_mapping, rc);
1807
rc = cifs_revalidate_dentry_attr(dentry);
1811
generic_fillattr(inode, stat);
1812
stat->blksize = CIFS_MAX_MSGSIZE;
1813
stat->ino = CIFS_I(inode)->uniqueid;
1816
* If on a multiuser mount without unix extensions, and the admin hasn't
1817
* overridden them, set the ownership to the fsuid/fsgid of the current
1820
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1822
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1823
stat->uid = current_fsuid();
1824
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1825
stat->gid = current_fsgid();
1830
static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1832
pgoff_t index = from >> PAGE_CACHE_SHIFT;
1833
unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1837
page = grab_cache_page(mapping, index);
1841
zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1843
page_cache_release(page);
1847
static void cifs_setsize(struct inode *inode, loff_t offset)
1851
spin_lock(&inode->i_lock);
1852
oldsize = inode->i_size;
1853
i_size_write(inode, offset);
1854
spin_unlock(&inode->i_lock);
1856
truncate_pagecache(inode, oldsize, offset);
1860
cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1861
int xid, char *full_path)
1864
struct cifsFileInfo *open_file;
1865
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1866
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1867
struct tcon_link *tlink = NULL;
1868
struct cifs_tcon *pTcon = NULL;
1869
struct cifs_io_parms io_parms;
1872
* To avoid spurious oplock breaks from server, in the case of
1873
* inodes that we already have open, avoid doing path based
1874
* setting of file size if we can do it by handle.
1875
* This keeps our caching token (oplock) and avoids timeouts
1876
* when the local oplock break takes longer to flush
1877
* writebehind data than the SMB timeout for the SetPathInfo
1878
* request would allow
1880
open_file = find_writable_file(cifsInode, true);
1882
__u16 nfid = open_file->netfid;
1883
__u32 npid = open_file->pid;
1884
pTcon = tlink_tcon(open_file->tlink);
1885
rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1887
cifsFileInfo_put(open_file);
1888
cFYI(1, "SetFSize for attrs rc = %d", rc);
1889
if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1890
unsigned int bytes_written;
1892
io_parms.netfid = nfid;
1893
io_parms.pid = npid;
1894
io_parms.tcon = pTcon;
1895
io_parms.offset = 0;
1896
io_parms.length = attrs->ia_size;
1897
rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1899
cFYI(1, "Wrt seteof rc %d", rc);
1905
if (pTcon == NULL) {
1906
tlink = cifs_sb_tlink(cifs_sb);
1908
return PTR_ERR(tlink);
1909
pTcon = tlink_tcon(tlink);
1912
/* Set file size by pathname rather than by handle
1913
either because no valid, writeable file handle for
1914
it was found or because there was an error setting
1916
rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1917
false, cifs_sb->local_nls,
1918
cifs_sb->mnt_cifs_flags &
1919
CIFS_MOUNT_MAP_SPECIAL_CHR);
1920
cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1921
if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1925
rc = SMBLegacyOpen(xid, pTcon, full_path,
1926
FILE_OPEN, GENERIC_WRITE,
1927
CREATE_NOT_DIR, &netfid, &oplock, NULL,
1929
cifs_sb->mnt_cifs_flags &
1930
CIFS_MOUNT_MAP_SPECIAL_CHR);
1932
unsigned int bytes_written;
1934
io_parms.netfid = netfid;
1935
io_parms.pid = current->tgid;
1936
io_parms.tcon = pTcon;
1937
io_parms.offset = 0;
1938
io_parms.length = attrs->ia_size;
1939
rc = CIFSSMBWrite(xid, &io_parms,
1942
cFYI(1, "wrt seteof rc %d", rc);
1943
CIFSSMBClose(xid, pTcon, netfid);
1947
cifs_put_tlink(tlink);
1951
cifsInode->server_eof = attrs->ia_size;
1952
cifs_setsize(inode, attrs->ia_size);
1953
cifs_truncate_page(inode->i_mapping, inode->i_size);
1960
cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1964
char *full_path = NULL;
1965
struct inode *inode = direntry->d_inode;
1966
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1967
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1968
struct tcon_link *tlink;
1969
struct cifs_tcon *pTcon;
1970
struct cifs_unix_set_info_args *args = NULL;
1971
struct cifsFileInfo *open_file;
1973
cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1974
direntry->d_name.name, attrs->ia_valid);
1978
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1979
attrs->ia_valid |= ATTR_FORCE;
1981
rc = inode_change_ok(inode, attrs);
1985
full_path = build_path_from_dentry(direntry);
1986
if (full_path == NULL) {
1992
* Attempt to flush data before changing attributes. We need to do
1993
* this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1994
* ownership or mode then we may also need to do this. Here, we take
1995
* the safe way out and just do the flush on all setattr requests. If
1996
* the flush returns error, store it to report later and continue.
1998
* BB: This should be smarter. Why bother flushing pages that
1999
* will be truncated anyway? Also, should we error out here if
2000
* the flush returns error?
2002
rc = filemap_write_and_wait(inode->i_mapping);
2003
mapping_set_error(inode->i_mapping, rc);
2006
if (attrs->ia_valid & ATTR_SIZE) {
2007
rc = cifs_set_file_size(inode, attrs, xid, full_path);
2012
/* skip mode change if it's just for clearing setuid/setgid */
2013
if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2014
attrs->ia_valid &= ~ATTR_MODE;
2016
args = kmalloc(sizeof(*args), GFP_KERNEL);
2022
/* set up the struct */
2023
if (attrs->ia_valid & ATTR_MODE)
2024
args->mode = attrs->ia_mode;
2026
args->mode = NO_CHANGE_64;
2028
if (attrs->ia_valid & ATTR_UID)
2029
args->uid = attrs->ia_uid;
2031
args->uid = NO_CHANGE_64;
2033
if (attrs->ia_valid & ATTR_GID)
2034
args->gid = attrs->ia_gid;
2036
args->gid = NO_CHANGE_64;
2038
if (attrs->ia_valid & ATTR_ATIME)
2039
args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2041
args->atime = NO_CHANGE_64;
2043
if (attrs->ia_valid & ATTR_MTIME)
2044
args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2046
args->mtime = NO_CHANGE_64;
2048
if (attrs->ia_valid & ATTR_CTIME)
2049
args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2051
args->ctime = NO_CHANGE_64;
2054
open_file = find_writable_file(cifsInode, true);
2056
u16 nfid = open_file->netfid;
2057
u32 npid = open_file->pid;
2058
pTcon = tlink_tcon(open_file->tlink);
2059
rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2060
cifsFileInfo_put(open_file);
2062
tlink = cifs_sb_tlink(cifs_sb);
2063
if (IS_ERR(tlink)) {
2064
rc = PTR_ERR(tlink);
2067
pTcon = tlink_tcon(tlink);
2068
rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2070
cifs_sb->mnt_cifs_flags &
2071
CIFS_MOUNT_MAP_SPECIAL_CHR);
2072
cifs_put_tlink(tlink);
2078
if ((attrs->ia_valid & ATTR_SIZE) &&
2079
attrs->ia_size != i_size_read(inode))
2080
truncate_setsize(inode, attrs->ia_size);
2082
setattr_copy(inode, attrs);
2083
mark_inode_dirty(inode);
2085
/* force revalidate when any of these times are set since some
2086
of the fs types (eg ext3, fat) do not have fine enough
2087
time granularity to match protocol, and we do not have a
2088
a way (yet) to query the server fs's time granularity (and
2089
whether it rounds times down).
2091
if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2092
cifsInode->time = 0;
2101
cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2104
uid_t uid = NO_CHANGE_32;
2105
gid_t gid = NO_CHANGE_32;
2106
struct inode *inode = direntry->d_inode;
2107
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2108
struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2109
char *full_path = NULL;
2112
__u64 mode = NO_CHANGE_64;
2116
cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2117
direntry->d_name.name, attrs->ia_valid);
2119
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2120
attrs->ia_valid |= ATTR_FORCE;
2122
rc = inode_change_ok(inode, attrs);
2128
full_path = build_path_from_dentry(direntry);
2129
if (full_path == NULL) {
2136
* Attempt to flush data before changing attributes. We need to do
2137
* this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2138
* ownership or mode then we may also need to do this. Here, we take
2139
* the safe way out and just do the flush on all setattr requests. If
2140
* the flush returns error, store it to report later and continue.
2142
* BB: This should be smarter. Why bother flushing pages that
2143
* will be truncated anyway? Also, should we error out here if
2144
* the flush returns error?
2146
rc = filemap_write_and_wait(inode->i_mapping);
2147
mapping_set_error(inode->i_mapping, rc);
2150
if (attrs->ia_valid & ATTR_SIZE) {
2151
rc = cifs_set_file_size(inode, attrs, xid, full_path);
2153
goto cifs_setattr_exit;
2156
if (attrs->ia_valid & ATTR_UID)
2157
uid = attrs->ia_uid;
2159
if (attrs->ia_valid & ATTR_GID)
2160
gid = attrs->ia_gid;
2162
#ifdef CONFIG_CIFS_ACL
2163
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2164
if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2165
rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2168
cFYI(1, "%s: Setting id failed with error: %d",
2170
goto cifs_setattr_exit;
2174
#endif /* CONFIG_CIFS_ACL */
2175
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2176
attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2178
/* skip mode change if it's just for clearing setuid/setgid */
2179
if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2180
attrs->ia_valid &= ~ATTR_MODE;
2182
if (attrs->ia_valid & ATTR_MODE) {
2183
mode = attrs->ia_mode;
2185
#ifdef CONFIG_CIFS_ACL
2186
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2187
rc = id_mode_to_cifs_acl(inode, full_path, mode,
2188
NO_CHANGE_32, NO_CHANGE_32);
2190
cFYI(1, "%s: Setting ACL failed with error: %d",
2192
goto cifs_setattr_exit;
2195
#endif /* CONFIG_CIFS_ACL */
2196
if (((mode & S_IWUGO) == 0) &&
2197
(cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2199
dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2201
/* fix up mode if we're not using dynperm */
2202
if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2203
attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2204
} else if ((mode & S_IWUGO) &&
2205
(cifsInode->cifsAttrs & ATTR_READONLY)) {
2207
dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2208
/* Attributes of 0 are ignored */
2210
dosattr |= ATTR_NORMAL;
2212
/* reset local inode permissions to normal */
2213
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2214
attrs->ia_mode &= ~(S_IALLUGO);
2215
if (S_ISDIR(inode->i_mode))
2217
cifs_sb->mnt_dir_mode;
2220
cifs_sb->mnt_file_mode;
2222
} else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2223
/* ignore mode change - ATTR_READONLY hasn't changed */
2224
attrs->ia_valid &= ~ATTR_MODE;
2228
if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2229
((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2230
rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2231
/* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2233
/* Even if error on time set, no sense failing the call if
2234
the server would set the time to a reasonable value anyway,
2235
and this check ensures that we are not being called from
2236
sys_utimes in which case we ought to fail the call back to
2237
the user when the server rejects the call */
2238
if ((rc) && (attrs->ia_valid &
2239
(ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2243
/* do not need local check to inode_check_ok since the server does
2246
goto cifs_setattr_exit;
2248
if ((attrs->ia_valid & ATTR_SIZE) &&
2249
attrs->ia_size != i_size_read(inode))
2250
truncate_setsize(inode, attrs->ia_size);
2252
setattr_copy(inode, attrs);
2253
mark_inode_dirty(inode);
2262
cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2264
struct inode *inode = direntry->d_inode;
2265
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2266
struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2268
if (pTcon->unix_ext)
2269
return cifs_setattr_unix(direntry, attrs);
2271
return cifs_setattr_nounix(direntry, attrs);
2273
/* BB: add cifs_setattr_legacy for really old servers */
2277
void cifs_delete_inode(struct inode *inode)
2279
cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2280
/* may have to add back in if and when safe distributed caching of
2281
directories added e.g. via FindNotify */