0d1412481b12404eb485447ca6e7d60ad355e493
[enigma2.git] / lib / python / Components / Harddisk.py
1 from os import system, listdir, statvfs, popen, makedirs, readlink, stat, major, minor
2 from Tools.Directories import SCOPE_HDD, resolveFilename
3 from Tools.CList import CList
4 from SystemInfo import SystemInfo
5 import time
6 from Components.Console import Console
7
8 def tryOpen(filename):
9         try:
10                 procFile = open(filename)
11         except IOError:
12                 return ""
13         return procFile
14
15 class Harddisk:
16         def __init__(self, device):
17                 self.device = device
18                 procfile = tryOpen("/sys/block/"+self.device+"/dev")
19                 tmp = procfile.readline().split(':')
20                 s_major = int(tmp[0])
21                 s_minor = int(tmp[1])
22                 self.max_idle_time = 0
23                 self.idle_running = False
24                 self.timer = None
25                 for disc in listdir("/dev/discs"):
26                         path = readlink('/dev/discs/'+disc)
27                         devidex = '/dev/discs/'+disc+'/'
28                         devidex2 = '/dev'+path[2:]+'/'
29                         disc = devidex2+'disc'
30                         ret = stat(disc).st_rdev
31                         if s_major == major(ret) and s_minor == minor(ret):
32                                 self.devidex = devidex
33                                 self.devidex2 = devidex2
34                                 print "new Harddisk", device, '->', self.devidex, '->', self.devidex2
35                                 self.startIdle()
36                                 break
37
38         def __lt__(self, ob):
39                 return self.device < ob.device
40
41         def stop(self):
42                 if self.timer:
43                         self.timer.stop()
44                         self.timer.callback.remove(self.runIdle)
45
46         def bus(self):
47                 ide_cf = self.device[:2] == "hd" and "host0" not in self.devidex2 # 7025 specific
48                 internal = self.device[:2] == "hd"
49                 if ide_cf:
50                         ret = "External (CF)"
51                 elif internal:
52                         ret = "Internal"
53                 else:
54                         ret = "External"
55                 return ret
56
57         def diskSize(self):
58                 procfile = tryOpen("/sys/block/"+self.device+"/size")
59                 if procfile == "":
60                         return 0
61                 line = procfile.readline()
62                 procfile.close()
63                 try:
64                         cap = int(line)
65                 except:
66                         return 0;
67                 return cap / 1000 * 512 / 1000
68
69         def capacity(self):
70                 cap = self.diskSize()
71                 if cap == 0:
72                         return ""
73                 return "%d.%03d GB" % (cap/1000, cap%1000)
74
75         def model(self):
76                 if self.device[:2] == "hd":
77                         procfile = tryOpen("/proc/ide/"+self.device+"/model")
78                         if procfile == "":
79                                 return ""
80                         line = procfile.readline()
81                         procfile.close()
82                         return line.strip()
83                 elif self.device[:2] == "sd":
84                         procfile = tryOpen("/sys/block/"+self.device+"/device/vendor")
85                         if procfile == "":
86                                 return ""
87                         vendor = procfile.readline().strip()
88                         procfile.close()
89                         procfile = tryOpen("/sys/block/"+self.device+"/device/model")
90                         model = procfile.readline().strip()
91                         return vendor+'('+model+')'
92                 else:
93                         assert False, "no hdX or sdX"
94
95         def free(self):
96                 procfile = tryOpen("/proc/mounts")
97                 
98                 if procfile == "":
99                         return -1
100
101                 free = -1
102                 while 1:
103                         line = procfile.readline()
104                         if line == "":
105                                 break
106                         if line.startswith(self.devidex) or line.startswith(self.devidex2):
107                                 parts = line.strip().split(" ")
108                                 try:
109                                         stat = statvfs(parts[1])
110                                 except OSError:
111                                         continue
112                                 free = stat.f_bfree/1000 * stat.f_bsize/1000
113                                 break
114                 procfile.close()
115                 return free
116
117         def numPartitions(self):
118                 try:
119                         idedir = listdir(self.devidex)
120                 except OSError:
121                         return -1
122                 numPart = -1
123                 for filename in idedir:
124                         if filename.startswith("disc"):
125                                 numPart += 1
126                         if filename.startswith("part"):
127                                 numPart += 1
128                 return numPart
129
130         def unmount(self):
131                 procfile = tryOpen("/proc/mounts")
132
133                 if procfile == "":
134                         return -1
135
136                 cmd = "/bin/umount"
137
138                 for line in procfile:
139                         if line.startswith(self.devidex) or line.startswith(self.devidex2):
140                                 parts = line.split()
141                                 cmd = ' '.join([cmd, parts[1]])
142
143                 procfile.close()
144
145                 res = system(cmd)
146                 return (res >> 8)
147
148         def createPartition(self):
149                 cmd = "/sbin/sfdisk -f " + self.devidex + "disc"
150                 sfdisk = popen(cmd, "w")
151                 sfdisk.write("0,\n;\n;\n;\ny\n")
152                 sfdisk.close()
153                 return 0
154
155         def mkfs(self):
156                 cmd = "/sbin/mkfs.ext3 "
157                 if self.diskSize() > 4 * 1024:
158                         cmd += "-T largefile "
159                 cmd += "-m0 -O dir_index " + self.devidex + "part1"
160                 res = system(cmd)
161                 return (res >> 8)
162
163         def mount(self):
164                 res = -1
165                 #we don't know which type of devicename is used in fstab, try both
166                 for device in [self.devidex, self.devidex2]:
167                         cmd = "/bin/mount -t ext3 " + device + "part1"
168                         res = system(cmd)
169                         res >>= 8
170                         if not res:
171                                 break
172                 return res
173
174         def createMovieFolder(self):
175                 try:
176                         makedirs(resolveFilename(SCOPE_HDD))
177                 except OSError:
178                         return -1
179                 return 0
180
181         def fsck(self):
182                 # We autocorrect any failures
183                 # TODO: we could check if the fs is actually ext3
184                 cmd = "/sbin/fsck.ext3 -f -p " + self.devidex + "part1"
185                 res = system(cmd)
186                 return (res >> 8)
187
188         errorList = [ _("Everything is fine"), _("Creating partition failed"), _("Mkfs failed"), _("Mount failed"), _("Create movie folder failed"), _("Fsck failed"), _("Please Reboot"), _("Filesystem contains uncorrectable errors"), _("Unmount failed")]
189
190         def initialize(self):
191                 self.unmount()
192
193                 if self.createPartition() != 0:
194                         return -1
195
196                 if self.mkfs() != 0:
197                         return -2
198
199                 if self.mount() != 0:
200                         return -3
201
202                 if self.createMovieFolder() != 0:
203                         return -4
204
205                 return 0
206
207         def check(self):
208                 self.unmount()
209
210                 res = self.fsck()
211                 if res & 2 == 2:
212                         return -6
213
214                 if res & 4 == 4:
215                         return -7
216
217                 if res != 0 and res != 1:
218                         # A sum containing 1 will also include a failure
219                         return -5
220
221                 if self.mount() != 0:
222                         return -3
223
224                 return 0
225         
226         def getDeviceDir(self):
227                 return self.devidex
228         
229         def getDeviceName(self):
230                 return self.getDeviceDir() + "disc"
231
232         # the HDD idle poll daemon.
233         # as some harddrives have a buggy standby timer, we are doing this by hand here.
234         # first, we disable the hardware timer. then, we check every now and then if
235         # any access has been made to the disc. If there has been no access over a specifed time,
236         # we set the hdd into standby.
237         def readStats(self):
238                 l = open("/sys/block/%s/stat" % self.device).read()
239                 (nr_read, _, _, _, nr_write) = l.split()[:5]
240                 return int(nr_read), int(nr_write)
241
242         def startIdle(self):
243                 self.last_access = time.time()
244                 self.last_stat = 0
245                 self.is_sleeping = False
246                 from enigma import eTimer
247
248                 # disable HDD standby timer
249                 Console().ePopen(("hdparm", "hdparm", "-S0", (self.devidex + "disc")))
250                 self.timer = eTimer()
251                 self.timer.callback.append(self.runIdle)
252                 self.idle_running = True
253                 self.setIdleTime(self.max_idle_time) # kick the idle polling loop
254
255         def runIdle(self):
256                 if not self.max_idle_time:
257                         return
258                 t = time.time()
259
260                 idle_time = t - self.last_access
261
262                 stats = self.readStats()
263                 print "nr_read", stats[0], "nr_write", stats[1]
264                 l = sum(stats)
265                 print "sum", l, "prev_sum", self.last_stat
266
267                 if l != self.last_stat: # access
268                         print "hdd was accessed since previous check!"
269                         self.last_stat = l
270                         self.last_access = t
271                         idle_time = 0
272                         self.is_sleeping = False
273                 else:
274                         print "hdd IDLE!"
275
276                 print "[IDLE]", idle_time, self.max_idle_time, self.is_sleeping
277                 if idle_time >= self.max_idle_time and not self.is_sleeping:
278                         self.setSleep()
279                         self.is_sleeping = True
280
281         def setSleep(self):
282                 Console().ePopen(("hdparm", "hdparm", "-y", (self.devidex + "disc")))
283
284         def setIdleTime(self, idle):
285                 self.max_idle_time = idle
286                 if self.idle_running:
287                         if not idle:
288                                 self.timer.stop()
289                         else:
290                                 self.timer.start(idle * 100, False)  # poll 10 times per period.
291
292         def isSleeping(self):
293                 return self.is_sleeping
294
295 class Partition:
296         def __init__(self, mountpoint, device = None, description = "", force_mounted = False):
297                 self.mountpoint = mountpoint
298                 self.description = description
299                 self.force_mounted = force_mounted
300                 self.is_hotplug = force_mounted # so far; this might change.
301                 self.device = device
302
303         def stat(self):
304                 return statvfs(self.mountpoint)
305
306         def free(self):
307                 try:
308                         s = self.stat()
309                         return s.f_bavail * s.f_bsize
310                 except OSError:
311                         return None
312         
313         def total(self):
314                 try:
315                         s = self.stat()
316                         return s.f_blocks * s.f_bsize
317                 except OSError:
318                         return None
319
320         def mounted(self):
321                 # THANK YOU PYTHON FOR STRIPPING AWAY f_fsid.
322                 # TODO: can os.path.ismount be used?
323                 if self.force_mounted:
324                         return True
325                 procfile = tryOpen("/proc/mounts")
326                 for n in procfile.readlines():
327                         if n.split(' ')[1] == self.mountpoint:
328                                 return True
329                 return False
330
331 DEVICEDB =  \
332         {
333                 # dm8000:
334                 "/devices/platform/brcm-ehci.0/usb1/1-1/1-1.1/1-1.1:1.0": "Front USB Slot",
335                 "/devices/platform/brcm-ehci.0/usb1/1-1/1-1.2/1-1.2:1.0": "Back, upper USB Slot",
336                 "/devices/platform/brcm-ehci.0/usb1/1-1/1-1.3/1-1.3:1.0": "Back, lower USB Slot",
337                 "/devices/platform/brcm-ehci-1.1/usb2/2-1/2-1:1.0/host1/target1:0:0/1:0:0:0": "DVD Drive",
338                 # dm800:
339                 "/devices/platform/brcm-ehci.0/usb1/1-2/1-2:1.0": "Upper USB Slot",
340                 "/devices/platform/brcm-ehci.0/usb1/1-1/1-1:1.0": "Lower USB Slot",
341                 # dm7025:
342                 "/devices/pci0000:00/0000:00:14.1/ide1/1.0": "CF Card Slot", #hdc
343                 "/devices/pci0000:00/0000:00:14.1/ide0/0.0": "Internal Harddisk"
344         }
345
346 class HarddiskManager:
347         def __init__(self):
348                 self.hdd = [ ]
349                 self.cd = ""
350                 self.partitions = [ ]
351                 
352                 self.on_partition_list_change = CList()
353                 
354                 self.enumerateBlockDevices()
355                 
356                 # currently, this is just an enumeration of what's possible,
357                 # this probably has to be changed to support automount stuff.
358                 # still, if stuff is mounted into the correct mountpoints by
359                 # external tools, everything is fine (until somebody inserts 
360                 # a second usb stick.)
361                 p = [
362                                         ("/media/hdd", _("Harddisk")), 
363                                         ("/media/card", _("Card")), 
364                                         ("/media/cf", _("Compact Flash")),
365                                         ("/media/mmc1", _("MMC Card")),
366                                         ("/media/net", _("Network Mount")),
367                                         ("/media/ram", _("Ram Disk")),
368                                         ("/media/usb", _("USB Stick")),
369                                         ("/", _("Internal Flash"))
370                                 ]
371                 
372                 self.partitions.extend([ Partition(mountpoint = x[0], description = x[1]) for x in p ])
373
374         def getBlockDevInfo(self, blockdev):
375                 devpath = "/sys/block/" + blockdev
376                 error = False
377                 removable = False
378                 blacklisted = False
379                 is_cdrom = False
380                 partitions = []
381                 try:
382                         removable = bool(int(open(devpath + "/removable").read()))
383                         dev = int(open(devpath + "/dev").read().split(':')[0])
384                         if dev in (7, 31): # loop, mtdblock
385                                 blacklisted = True
386                         if blockdev[0:2] == 'sr':
387                                 is_cdrom = True
388                         if blockdev[0:2] == 'hd':
389                                 try:
390                                         media = open("/proc/ide/%s/media" % blockdev).read()
391                                         if "cdrom" in media:
392                                                 is_cdrom = True
393                                 except IOError:
394                                         error = True
395                         # check for partitions
396                         if not is_cdrom:
397                                 for partition in listdir(devpath):
398                                         if partition[0:len(blockdev)] != blockdev:
399                                                 continue
400                                         partitions.append(partition)
401                         else:
402                                 self.cd = blockdev
403                 except IOError:
404                         error = True
405                 # check for medium
406                 medium_found = True
407                 try:
408                         open("/dev/" + blockdev).close()
409                 except IOError, err:
410                         if err.errno == 159: # no medium present
411                                 medium_found = False
412                         
413                 return error, blacklisted, removable, is_cdrom, partitions, medium_found
414
415         def enumerateBlockDevices(self):
416                 print "enumerating block devices..."
417                 for blockdev in listdir("/sys/block"):
418                         error, blacklisted, removable, is_cdrom, partitions, medium_found = self.getBlockDevInfo(blockdev)
419                         print "found block device '%s':" % blockdev, 
420                         if error:
421                                 print "error querying properties"
422                         elif blacklisted:
423                                 print "blacklisted"
424                         elif not medium_found:
425                                 print "no medium"
426                         else:
427                                 print "ok, removable=%s, cdrom=%s, partitions=%s, device=%s" % (removable, is_cdrom, partitions, blockdev)
428
429                                 self.addHotplugPartition(blockdev)
430                                 for part in partitions:
431                                         self.addHotplugPartition(part)
432
433         def getAutofsMountpoint(self, device):
434                 return "/autofs/%s/" % (device)
435
436         def addHotplugPartition(self, device, physdev = None):
437                 if not physdev:
438                         dev, part = self.splitDeviceName(device)
439                         try:
440                                 physdev = readlink("/sys/block/" + dev + "/device")[5:]
441                         except OSError:
442                                 physdev = dev
443                                 print "couldn't determine blockdev physdev for device", device
444
445                 # device is the device name, without /dev 
446                 # physdev is the physical device path, which we (might) use to determine the userfriendly name
447                 description = self.getUserfriendlyDeviceName(device, physdev)
448                 
449                 p = Partition(mountpoint = self.getAutofsMountpoint(device), description = description, force_mounted = True, device = device)
450                 self.partitions.append(p)
451                 self.on_partition_list_change("add", p)
452
453                 # see if this is a harddrive
454                 l = len(device)
455                 if l and not device[l-1].isdigit():
456                         error, blacklisted, removable, is_cdrom, partitions, medium_found = self.getBlockDevInfo(device)
457                         if not blacklisted and not removable and not is_cdrom and medium_found:
458                                 self.hdd.append(Harddisk(device))
459                                 self.hdd.sort()
460                                 SystemInfo["Harddisk"] = len(self.hdd) > 0
461
462         def removeHotplugPartition(self, device):
463                 mountpoint = self.getAutofsMountpoint(device)
464                 for x in self.partitions[:]:
465                         if x.mountpoint == mountpoint:
466                                 self.partitions.remove(x)
467                                 self.on_partition_list_change("remove", x)
468                 l = len(device)
469                 if l and not device[l-1].isdigit():
470                         for hdd in self.hdd:
471                                 if hdd.device == device:
472                                         hdd.stop()
473                                         self.hdd.remove(hdd)
474                                         break
475                         SystemInfo["Harddisk"] = len(self.hdd) > 0
476
477         def HDDCount(self):
478                 return len(self.hdd)
479
480         def HDDList(self):
481                 list = [ ]
482                 for hd in self.hdd:
483                         hdd = hd.model() + " - " + hd.bus()
484                         cap = hd.capacity()
485                         if cap != "":
486                                 hdd += " (" + cap + ")"
487                         list.append((hdd, hd))
488                 return list
489
490         def getCD(self):
491                 return self.cd
492
493         def getMountedPartitions(self, onlyhotplug = False):
494                 parts = [x for x in self.partitions if (x.is_hotplug or not onlyhotplug) and x.mounted()]
495                 devs = set([x.device for x in parts])
496                 for devname in devs.copy():
497                         if not devname:
498                                 continue
499                         dev, part = self.splitDeviceName(devname)
500                         if part and dev in devs: # if this is a partition and we still have the wholedisk, remove wholedisk
501                                 devs.remove(dev)
502
503                 # return all devices which are not removed due to being a wholedisk when a partition exists
504                 return [x for x in parts if not x.device or x.device in devs]
505
506         def splitDeviceName(self, devname):
507                 # this works for: sdaX, hdaX, sr0 (which is in fact dev="sr0", part=""). It doesn't work for other names like mtdblock3, but they are blacklisted anyway.
508                 dev = devname[:3]
509                 part = devname[3:]
510                 for p in part:
511                         if not p.isdigit():
512                                 return devname, 0
513                 return dev, part and int(part) or 0
514
515         def getUserfriendlyDeviceName(self, dev, phys):
516                 dev, part = self.splitDeviceName(dev)
517                 description = "External Storage %s" % dev
518                 try:
519                         description = open("/sys" + phys + "/model").read().strip()
520                 except IOError, s:
521                         print "couldn't read model: ", s
522                 for physdevprefix, pdescription in DEVICEDB.items():
523                         if phys.startswith(physdevprefix):
524                                 description = pdescription
525
526                 # not wholedisk and not partition 1
527                 if part and part != 1:
528                         description += " (Partition %d)" % part
529                 return description
530
531         def addMountedPartition(self, device, desc):
532                 already_mounted = False
533                 for x in self.partitions[:]:
534                         if x.mountpoint == device:
535                                 already_mounted = True
536                 if not already_mounted:
537                         self.partitions.append(Partition(mountpoint = device, description = desc))
538                 
539         def removeMountedPartition(self, mountpoint):
540                 for x in self.partitions[:]:
541                         if x.mountpoint == mountpoint:
542                                 self.partitions.remove(x)
543                                 self.on_partition_list_change("remove", x)
544
545 harddiskmanager = HarddiskManager()